Upload 884 files

.gitattributes

@@ -34,3 +34,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 task_generator/prompts_raw/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-chemistry/examples/examples_assets/CustomGraphMoleculeAnimation.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-chemistry/examples/examples_assets/Draw3DMorphine_ManimCE_v0.17.3.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-chemistry/examples/examples_assets/DrawPeriodicTable_ManimCE_v0.17.3.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-chemistry/examples/examples_assets/Fullerene.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-chemistry/examples/examples_assets/TinPhases.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-circuit/examples/all-parts-and-variants/AllPartsAndVariants_ManimCE_v0.18.1.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/CNNScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/DisentanglementScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/GANScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/ImageNeuralNetworkScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/ManimMLLogo.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/NNImage.png filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/TestNeuralNetworkScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/media/VAEScene.gif filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/variational_autoencoder/autoencoder_models/data/MNIST/raw/t10k-images-idx3-ubyte filter=lfs diff=lfs merge=lfs -text
+data/rag/manim_docs/plugin_docs/manim-ml/examples/variational_autoencoder/autoencoder_models/data/MNIST/raw/train-images-idx3-ubyte filter=lfs diff=lfs merge=lfs -text

data/rag/manim_docs/manim_core/docs/examples.md

@@ -0,0 +1,1776 @@
+# Example Gallery
+
+This gallery contains a collection of best practice code snippets
+together with their corresponding video/image output, illustrating
+different functionalities all across the library.
+These are all under the MIT license, so feel free to copy & paste them to your projects.
+Enjoy this taste of Manim!
+
+## Basic Concepts
+
+<div id="manimcelogo" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ManimCELogo <a class="headerlink" href="#manimcelogo">¶</a></p>![image](media/images/ManimCELogo-1.png)
+```python
+from manim import *
+
+class ManimCELogo(Scene):
+    def construct(self):
+        self.camera.background_color = "#ece6e2"
+        logo_green = "#87c2a5"
+        logo_blue = "#525893"
+        logo_red = "#e07a5f"
+        logo_black = "#343434"
+        ds_m = MathTex(r"\mathbb{M}", fill_color=logo_black).scale(7)
+        ds_m.shift(2.25 * LEFT + 1.5 * UP)
+        circle = Circle(color=logo_green, fill_opacity=1).shift(LEFT)
+        square = Square(color=logo_blue, fill_opacity=1).shift(UP)
+        triangle = Triangle(color=logo_red, fill_opacity=1).shift(RIGHT)
+        logo = VGroup(triangle, square, circle, ds_m)  # order matters
+        logo.move_to(ORIGIN)
+        self.add(logo)
+```
+
+<pre data-manim-binder data-manim-classname="ManimCELogo">
+class ManimCELogo(Scene):
+    def construct(self):
+        self.camera.background_color = "#ece6e2"
+        logo_green = "#87c2a5"
+        logo_blue = "#525893"
+        logo_red = "#e07a5f"
+        logo_black = "#343434"
+        ds_m = MathTex(r"\\mathbb{M}", fill_color=logo_black).scale(7)
+        ds_m.shift(2.25 \* LEFT + 1.5 \* UP)
+        circle = Circle(color=logo_green, fill_opacity=1).shift(LEFT)
+        square = Square(color=logo_blue, fill_opacity=1).shift(UP)
+        triangle = Triangle(color=logo_red, fill_opacity=1).shift(RIGHT)
+        logo = VGroup(triangle, square, circle, ds_m)  # order matters
+        logo.move_to(ORIGIN)
+        self.add(logo)
+
+</pre>
+
+References: [`MathTex`](reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) [`Circle`](reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) [`Square`](reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square) [`Triangle`](reference/manim.mobject.geometry.polygram.Triangle.md#manim.mobject.geometry.polygram.Triangle)
+
+</div><div id="braceannotation" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: BraceAnnotation <a class="headerlink" href="#braceannotation">¶</a></p>![image](media/images/BraceAnnotation-1.png)
+```python
+from manim import *
+
+class BraceAnnotation(Scene):
+    def construct(self):
+        dot = Dot([-2, -1, 0])
+        dot2 = Dot([2, 1, 0])
+        line = Line(dot.get_center(), dot2.get_center()).set_color(ORANGE)
+        b1 = Brace(line)
+        b1text = b1.get_text("Horizontal distance")
+        b2 = Brace(line, direction=line.copy().rotate(PI / 2).get_unit_vector())
+        b2text = b2.get_tex("x-x_1")
+        self.add(line, dot, dot2, b1, b2, b1text, b2text)
+```
+
+<pre data-manim-binder data-manim-classname="BraceAnnotation">
+class BraceAnnotation(Scene):
+    def construct(self):
+        dot = Dot([-2, -1, 0])
+        dot2 = Dot([2, 1, 0])
+        line = Line(dot.get_center(), dot2.get_center()).set_color(ORANGE)
+        b1 = Brace(line)
+        b1text = b1.get_text("Horizontal distance")
+        b2 = Brace(line, direction=line.copy().rotate(PI / 2).get_unit_vector())
+        b2text = b2.get_tex("x-x_1")
+        self.add(line, dot, dot2, b1, b2, b1text, b2text)
+
+</pre>
+
+References: [`Brace`](reference/manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) [`get_text()`](reference/manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace.get_text) [`get_tex()`](reference/manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace.get_tex)
+
+</div><div id="vectorarrow" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: VectorArrow <a class="headerlink" href="#vectorarrow">¶</a></p>![image](media/images/VectorArrow-1.png)
+```python
+from manim import *
+
+class VectorArrow(Scene):
+    def construct(self):
+        dot = Dot(ORIGIN)
+        arrow = Arrow(ORIGIN, [2, 2, 0], buff=0)
+        numberplane = NumberPlane()
+        origin_text = Text('(0, 0)').next_to(dot, DOWN)
+        tip_text = Text('(2, 2)').next_to(arrow.get_end(), RIGHT)
+        self.add(numberplane, dot, arrow, origin_text, tip_text)
+```
+
+<pre data-manim-binder data-manim-classname="VectorArrow">
+class VectorArrow(Scene):
+    def construct(self):
+        dot = Dot(ORIGIN)
+        arrow = Arrow(ORIGIN, [2, 2, 0], buff=0)
+        numberplane = NumberPlane()
+        origin_text = Text('(0, 0)').next_to(dot, DOWN)
+        tip_text = Text('(2, 2)').next_to(arrow.get_end(), RIGHT)
+        self.add(numberplane, dot, arrow, origin_text, tip_text)
+
+</pre>
+
+References: [`Dot`](reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) [`Arrow`](reference/manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) [`NumberPlane`](reference/manim.mobject.graphing.coordinate_systems.NumberPlane.md#manim.mobject.graphing.coordinate_systems.NumberPlane) [`Text`](reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+</div><div id="gradientimagefromarray" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GradientImageFromArray <a class="headerlink" href="#gradientimagefromarray">¶</a></p>![image](media/images/GradientImageFromArray-1.png)
+```python
+from manim import *
+
+class GradientImageFromArray(Scene):
+    def construct(self):
+        n = 256
+        imageArray = np.uint8(
+            [[i * 256 / n for i in range(0, n)] for _ in range(0, n)]
+        )
+        image = ImageMobject(imageArray).scale(2)
+        image.background_rectangle = SurroundingRectangle(image, color=GREEN)
+        self.add(image, image.background_rectangle)
+```
+
+<pre data-manim-binder data-manim-classname="GradientImageFromArray">
+class GradientImageFromArray(Scene):
+    def construct(self):
+        n = 256
+        imageArray = np.uint8(
+            [[i \* 256 / n for i in range(0, n)] for \_ in range(0, n)]
+        )
+        image = ImageMobject(imageArray).scale(2)
+        image.background_rectangle = SurroundingRectangle(image, color=GREEN)
+        self.add(image, image.background_rectangle)
+
+</pre>
+
+References: [`ImageMobject`](reference/manim.mobject.types.image_mobject.ImageMobject.md#manim.mobject.types.image_mobject.ImageMobject)
+
+</div><div id="booleanoperations" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: BooleanOperations <a class="headerlink" href="#booleanoperations">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./BooleanOperations-1.mp4">
+</video>
+```python
+from manim import *
+
+class BooleanOperations(Scene):
+    def construct(self):
+        ellipse1 = Ellipse(
+            width=4.0, height=5.0, fill_opacity=0.5, color=BLUE, stroke_width=10
+        ).move_to(LEFT)
+        ellipse2 = ellipse1.copy().set_color(color=RED).move_to(RIGHT)
+        bool_ops_text = MarkupText("<u>Boolean Operation</u>").next_to(ellipse1, UP * 3)
+        ellipse_group = Group(bool_ops_text, ellipse1, ellipse2).move_to(LEFT * 3)
+        self.play(FadeIn(ellipse_group))
+
+        i = Intersection(ellipse1, ellipse2, color=GREEN, fill_opacity=0.5)
+        self.play(i.animate.scale(0.25).move_to(RIGHT * 5 + UP * 2.5))
+        intersection_text = Text("Intersection", font_size=23).next_to(i, UP)
+        self.play(FadeIn(intersection_text))
+
+        u = Union(ellipse1, ellipse2, color=ORANGE, fill_opacity=0.5)
+        union_text = Text("Union", font_size=23)
+        self.play(u.animate.scale(0.3).next_to(i, DOWN, buff=union_text.height * 3))
+        union_text.next_to(u, UP)
+        self.play(FadeIn(union_text))
+
+        e = Exclusion(ellipse1, ellipse2, color=YELLOW, fill_opacity=0.5)
+        exclusion_text = Text("Exclusion", font_size=23)
+        self.play(e.animate.scale(0.3).next_to(u, DOWN, buff=exclusion_text.height * 3.5))
+        exclusion_text.next_to(e, UP)
+        self.play(FadeIn(exclusion_text))
+
+        d = Difference(ellipse1, ellipse2, color=PINK, fill_opacity=0.5)
+        difference_text = Text("Difference", font_size=23)
+        self.play(d.animate.scale(0.3).next_to(u, LEFT, buff=difference_text.height * 3.5))
+        difference_text.next_to(d, UP)
+        self.play(FadeIn(difference_text))
+```
+
+<pre data-manim-binder data-manim-classname="BooleanOperations">
+class BooleanOperations(Scene):
+    def construct(self):
+        ellipse1 = Ellipse(
+            width=4.0, height=5.0, fill_opacity=0.5, color=BLUE, stroke_width=10
+        ).move_to(LEFT)
+        ellipse2 = ellipse1.copy().set_color(color=RED).move_to(RIGHT)
+        bool_ops_text = MarkupText("<u>Boolean Operation</u>").next_to(ellipse1, UP \* 3)
+        ellipse_group = Group(bool_ops_text, ellipse1, ellipse2).move_to(LEFT \* 3)
+        self.play(FadeIn(ellipse_group))
+
+        i = Intersection(ellipse1, ellipse2, color=GREEN, fill_opacity=0.5)
+        self.play(i.animate.scale(0.25).move_to(RIGHT \* 5 + UP \* 2.5))
+        intersection_text = Text("Intersection", font_size=23).next_to(i, UP)
+        self.play(FadeIn(intersection_text))
+
+        u = Union(ellipse1, ellipse2, color=ORANGE, fill_opacity=0.5)
+        union_text = Text("Union", font_size=23)
+        self.play(u.animate.scale(0.3).next_to(i, DOWN, buff=union_text.height \* 3))
+        union_text.next_to(u, UP)
+        self.play(FadeIn(union_text))
+
+        e = Exclusion(ellipse1, ellipse2, color=YELLOW, fill_opacity=0.5)
+        exclusion_text = Text("Exclusion", font_size=23)
+        self.play(e.animate.scale(0.3).next_to(u, DOWN, buff=exclusion_text.height \* 3.5))
+        exclusion_text.next_to(e, UP)
+        self.play(FadeIn(exclusion_text))
+
+        d = Difference(ellipse1, ellipse2, color=PINK, fill_opacity=0.5)
+        difference_text = Text("Difference", font_size=23)
+        self.play(d.animate.scale(0.3).next_to(u, LEFT, buff=difference_text.height \* 3.5))
+        difference_text.next_to(d, UP)
+        self.play(FadeIn(difference_text))
+
+</pre>
+
+References: [`Union`](reference/manim.mobject.geometry.boolean_ops.Union.md#manim.mobject.geometry.boolean_ops.Union) [`Intersection`](reference/manim.mobject.geometry.boolean_ops.Intersection.md#manim.mobject.geometry.boolean_ops.Intersection) [`Exclusion`](reference/manim.mobject.geometry.boolean_ops.Exclusion.md#manim.mobject.geometry.boolean_ops.Exclusion) [`Difference`](reference/manim.mobject.geometry.boolean_ops.Difference.md#manim.mobject.geometry.boolean_ops.Difference)
+
+</div>
+
+## Animations
+
+<div id="pointmovingonshapes" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: PointMovingOnShapes <a class="headerlink" href="#pointmovingonshapes">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./PointMovingOnShapes-1.mp4">
+</video>
+```python
+from manim import *
+
+class PointMovingOnShapes(Scene):
+    def construct(self):
+        circle = Circle(radius=1, color=BLUE)
+        dot = Dot()
+        dot2 = dot.copy().shift(RIGHT)
+        self.add(dot)
+
+        line = Line([3, 0, 0], [5, 0, 0])
+        self.add(line)
+
+        self.play(GrowFromCenter(circle))
+        self.play(Transform(dot, dot2))
+        self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
+        self.play(Rotating(dot, about_point=[2, 0, 0]), run_time=1.5)
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="PointMovingOnShapes">
+class PointMovingOnShapes(Scene):
+    def construct(self):
+        circle = Circle(radius=1, color=BLUE)
+        dot = Dot()
+        dot2 = dot.copy().shift(RIGHT)
+        self.add(dot)
+
+        line = Line([3, 0, 0], [5, 0, 0])
+        self.add(line)
+
+        self.play(GrowFromCenter(circle))
+        self.play(Transform(dot, dot2))
+        self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
+        self.play(Rotating(dot, about_point=[2, 0, 0]), run_time=1.5)
+        self.wait()
+
+</pre>
+
+References: [`Circle`](reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) [`Dot`](reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) [`Line`](reference/manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) [`GrowFromCenter`](reference/manim.animation.growing.GrowFromCenter.md#manim.animation.growing.GrowFromCenter) [`Transform`](reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform) [`MoveAlongPath`](reference/manim.animation.movement.MoveAlongPath.md#manim.animation.movement.MoveAlongPath) [`Rotating`](reference/manim.animation.rotation.Rotating.md#manim.animation.rotation.Rotating)
+
+</div><div id="movingaround" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingAround <a class="headerlink" href="#movingaround">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingAround-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingAround(Scene):
+    def construct(self):
+        square = Square(color=BLUE, fill_opacity=1)
+
+        self.play(square.animate.shift(LEFT))
+        self.play(square.animate.set_fill(ORANGE))
+        self.play(square.animate.scale(0.3))
+        self.play(square.animate.rotate(0.4))
+```
+
+<pre data-manim-binder data-manim-classname="MovingAround">
+class MovingAround(Scene):
+    def construct(self):
+        square = Square(color=BLUE, fill_opacity=1)
+
+        self.play(square.animate.shift(LEFT))
+        self.play(square.animate.set_fill(ORANGE))
+        self.play(square.animate.scale(0.3))
+        self.play(square.animate.rotate(0.4))
+
+</pre>
+
+References: [`shift()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.shift) [`set_fill()`](reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.set_fill) [`scale()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.scale) [`rotate()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.rotate)
+
+</div><div id="movingangle" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingAngle <a class="headerlink" href="#movingangle">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingAngle-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingAngle(Scene):
+    def construct(self):
+        rotation_center = LEFT
+
+        theta_tracker = ValueTracker(110)
+        line1 = Line(LEFT, RIGHT)
+        line_moving = Line(LEFT, RIGHT)
+        line_ref = line_moving.copy()
+        line_moving.rotate(
+            theta_tracker.get_value() * DEGREES, about_point=rotation_center
+        )
+        a = Angle(line1, line_moving, radius=0.5, other_angle=False)
+        tex = MathTex(r"\theta").move_to(
+            Angle(
+                line1, line_moving, radius=0.5 + 3 * SMALL_BUFF, other_angle=False
+            ).point_from_proportion(0.5)
+        )
+
+        self.add(line1, line_moving, a, tex)
+        self.wait()
+
+        line_moving.add_updater(
+            lambda x: x.become(line_ref.copy()).rotate(
+                theta_tracker.get_value() * DEGREES, about_point=rotation_center
+            )
+        )
+
+        a.add_updater(
+            lambda x: x.become(Angle(line1, line_moving, radius=0.5, other_angle=False))
+        )
+        tex.add_updater(
+            lambda x: x.move_to(
+                Angle(
+                    line1, line_moving, radius=0.5 + 3 * SMALL_BUFF, other_angle=False
+                ).point_from_proportion(0.5)
+            )
+        )
+
+        self.play(theta_tracker.animate.set_value(40))
+        self.play(theta_tracker.animate.increment_value(140))
+        self.play(tex.animate.set_color(RED), run_time=0.5)
+        self.play(theta_tracker.animate.set_value(350))
+```
+
+<pre data-manim-binder data-manim-classname="MovingAngle">
+class MovingAngle(Scene):
+    def construct(self):
+        rotation_center = LEFT
+
+        theta_tracker = ValueTracker(110)
+        line1 = Line(LEFT, RIGHT)
+        line_moving = Line(LEFT, RIGHT)
+        line_ref = line_moving.copy()
+        line_moving.rotate(
+            theta_tracker.get_value() \* DEGREES, about_point=rotation_center
+        )
+        a = Angle(line1, line_moving, radius=0.5, other_angle=False)
+        tex = MathTex(r"\\theta").move_to(
+            Angle(
+                line1, line_moving, radius=0.5 + 3 \* SMALL_BUFF, other_angle=False
+            ).point_from_proportion(0.5)
+        )
+
+        self.add(line1, line_moving, a, tex)
+        self.wait()
+
+        line_moving.add_updater(
+            lambda x: x.become(line_ref.copy()).rotate(
+                theta_tracker.get_value() \* DEGREES, about_point=rotation_center
+            )
+        )
+
+        a.add_updater(
+            lambda x: x.become(Angle(line1, line_moving, radius=0.5, other_angle=False))
+        )
+        tex.add_updater(
+            lambda x: x.move_to(
+                Angle(
+                    line1, line_moving, radius=0.5 + 3 \* SMALL_BUFF, other_angle=False
+                ).point_from_proportion(0.5)
+            )
+        )
+
+        self.play(theta_tracker.animate.set_value(40))
+        self.play(theta_tracker.animate.increment_value(140))
+        self.play(tex.animate.set_color(RED), run_time=0.5)
+        self.play(theta_tracker.animate.set_value(350))
+
+</pre>
+
+References: [`Angle`](reference/manim.mobject.geometry.line.Angle.md#manim.mobject.geometry.line.Angle) [`rotate()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.rotate)
+
+</div><div id="movingdots" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingDots <a class="headerlink" href="#movingdots">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingDots-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingDots(Scene):
+    def construct(self):
+        d1,d2=Dot(color=BLUE),Dot(color=GREEN)
+        dg=VGroup(d1,d2).arrange(RIGHT,buff=1)
+        l1=Line(d1.get_center(),d2.get_center()).set_color(RED)
+        x=ValueTracker(0)
+        y=ValueTracker(0)
+        d1.add_updater(lambda z: z.set_x(x.get_value()))
+        d2.add_updater(lambda z: z.set_y(y.get_value()))
+        l1.add_updater(lambda z: z.become(Line(d1.get_center(),d2.get_center())))
+        self.add(d1,d2,l1)
+        self.play(x.animate.set_value(5))
+        self.play(y.animate.set_value(4))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="MovingDots">
+class MovingDots(Scene):
+    def construct(self):
+        d1,d2=Dot(color=BLUE),Dot(color=GREEN)
+        dg=VGroup(d1,d2).arrange(RIGHT,buff=1)
+        l1=Line(d1.get_center(),d2.get_center()).set_color(RED)
+        x=ValueTracker(0)
+        y=ValueTracker(0)
+        d1.add_updater(lambda z: z.set_x(x.get_value()))
+        d2.add_updater(lambda z: z.set_y(y.get_value()))
+        l1.add_updater(lambda z: z.become(Line(d1.get_center(),d2.get_center())))
+        self.add(d1,d2,l1)
+        self.play(x.animate.set_value(5))
+        self.play(y.animate.set_value(4))
+        self.wait()
+
+</pre></div><div id="movinggrouptodestination" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingGroupToDestination <a class="headerlink" href="#movinggrouptodestination">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingGroupToDestination-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingGroupToDestination(Scene):
+    def construct(self):
+        group = VGroup(Dot(LEFT), Dot(ORIGIN), Dot(RIGHT, color=RED), Dot(2 * RIGHT)).scale(1.4)
+        dest = Dot([4, 3, 0], color=YELLOW)
+        self.add(group, dest)
+        self.play(group.animate.shift(dest.get_center() - group[2].get_center()))
+        self.wait(0.5)
+```
+
+<pre data-manim-binder data-manim-classname="MovingGroupToDestination">
+class MovingGroupToDestination(Scene):
+    def construct(self):
+        group = VGroup(Dot(LEFT), Dot(ORIGIN), Dot(RIGHT, color=RED), Dot(2 \* RIGHT)).scale(1.4)
+        dest = Dot([4, 3, 0], color=YELLOW)
+        self.add(group, dest)
+        self.play(group.animate.shift(dest.get_center() - group[2].get_center()))
+        self.wait(0.5)
+
+</pre></div><div id="movingframebox" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingFrameBox <a class="headerlink" href="#movingframebox">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingFrameBox-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingFrameBox(Scene):
+    def construct(self):
+        text=MathTex(
+            "\\frac{d}{dx}f(x)g(x)=","f(x)\\frac{d}{dx}g(x)","+",
+            "g(x)\\frac{d}{dx}f(x)"
+        )
+        self.play(Write(text))
+        framebox1 = SurroundingRectangle(text[1], buff = .1)
+        framebox2 = SurroundingRectangle(text[3], buff = .1)
+        self.play(
+            Create(framebox1),
+        )
+        self.wait()
+        self.play(
+            ReplacementTransform(framebox1,framebox2),
+        )
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="MovingFrameBox">
+class MovingFrameBox(Scene):
+    def construct(self):
+        text=MathTex(
+            "\\\\frac{d}{dx}f(x)g(x)=","f(x)\\\\frac{d}{dx}g(x)","+",
+            "g(x)\\\\frac{d}{dx}f(x)"
+        )
+        self.play(Write(text))
+        framebox1 = SurroundingRectangle(text[1], buff = .1)
+        framebox2 = SurroundingRectangle(text[3], buff = .1)
+        self.play(
+            Create(framebox1),
+        )
+        self.wait()
+        self.play(
+            ReplacementTransform(framebox1,framebox2),
+        )
+        self.wait()
+
+</pre>
+
+References: `tex_mobject` [`MathTex`](reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) [`SurroundingRectangle`](reference/manim.mobject.geometry.shape_matchers.SurroundingRectangle.md#manim.mobject.geometry.shape_matchers.SurroundingRectangle)
+
+</div><div id="rotationupdater" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: RotationUpdater <a class="headerlink" href="#rotationupdater">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./RotationUpdater-1.mp4">
+</video>
+```python
+from manim import *
+
+class RotationUpdater(Scene):
+    def construct(self):
+        def updater_forth(mobj, dt):
+            mobj.rotate_about_origin(dt)
+        def updater_back(mobj, dt):
+            mobj.rotate_about_origin(-dt)
+        line_reference = Line(ORIGIN, LEFT).set_color(WHITE)
+        line_moving = Line(ORIGIN, LEFT).set_color(YELLOW)
+        line_moving.add_updater(updater_forth)
+        self.add(line_reference, line_moving)
+        self.wait(2)
+        line_moving.remove_updater(updater_forth)
+        line_moving.add_updater(updater_back)
+        self.wait(2)
+        line_moving.remove_updater(updater_back)
+        self.wait(0.5)
+```
+
+<pre data-manim-binder data-manim-classname="RotationUpdater">
+class RotationUpdater(Scene):
+    def construct(self):
+        def updater_forth(mobj, dt):
+            mobj.rotate_about_origin(dt)
+        def updater_back(mobj, dt):
+            mobj.rotate_about_origin(-dt)
+        line_reference = Line(ORIGIN, LEFT).set_color(WHITE)
+        line_moving = Line(ORIGIN, LEFT).set_color(YELLOW)
+        line_moving.add_updater(updater_forth)
+        self.add(line_reference, line_moving)
+        self.wait(2)
+        line_moving.remove_updater(updater_forth)
+        line_moving.add_updater(updater_back)
+        self.wait(2)
+        line_moving.remove_updater(updater_back)
+        self.wait(0.5)
+
+</pre>
+
+References: [`add_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) [`remove_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.remove_updater)
+
+</div><div id="pointwithtrace" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: PointWithTrace <a class="headerlink" href="#pointwithtrace">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./PointWithTrace-1.mp4">
+</video>
+```python
+from manim import *
+
+class PointWithTrace(Scene):
+    def construct(self):
+        path = VMobject()
+        dot = Dot()
+        path.set_points_as_corners([dot.get_center(), dot.get_center()])
+        def update_path(path):
+            previous_path = path.copy()
+            previous_path.add_points_as_corners([dot.get_center()])
+            path.become(previous_path)
+        path.add_updater(update_path)
+        self.add(path, dot)
+        self.play(Rotating(dot, radians=PI, about_point=RIGHT, run_time=2))
+        self.wait()
+        self.play(dot.animate.shift(UP))
+        self.play(dot.animate.shift(LEFT))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="PointWithTrace">
+class PointWithTrace(Scene):
+    def construct(self):
+        path = VMobject()
+        dot = Dot()
+        path.set_points_as_corners([dot.get_center(), dot.get_center()])
+        def update_path(path):
+            previous_path = path.copy()
+            previous_path.add_points_as_corners([dot.get_center()])
+            path.become(previous_path)
+        path.add_updater(update_path)
+        self.add(path, dot)
+        self.play(Rotating(dot, radians=PI, about_point=RIGHT, run_time=2))
+        self.wait()
+        self.play(dot.animate.shift(UP))
+        self.play(dot.animate.shift(LEFT))
+        self.wait()
+
+</pre>
+
+References: [`Rotating`](reference/manim.animation.rotation.Rotating.md#manim.animation.rotation.Rotating) [`set_points_as_corners()`](reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.set_points_as_corners) [`add_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater)
+
+</div>
+
+## Plotting with Manim
+
+<div id="sinandcosfunctionplot" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SinAndCosFunctionPlot <a class="headerlink" href="#sinandcosfunctionplot">¶</a></p>![image](media/images/SinAndCosFunctionPlot-1.png)
+```python
+from manim import *
+
+class SinAndCosFunctionPlot(Scene):
+    def construct(self):
+        axes = Axes(
+            x_range=[-10, 10.3, 1],
+            y_range=[-1.5, 1.5, 1],
+            x_length=10,
+            axis_config={"color": GREEN},
+            x_axis_config={
+                "numbers_to_include": np.arange(-10, 10.01, 2),
+                "numbers_with_elongated_ticks": np.arange(-10, 10.01, 2),
+            },
+            tips=False,
+        )
+        axes_labels = axes.get_axis_labels()
+        sin_graph = axes.plot(lambda x: np.sin(x), color=BLUE)
+        cos_graph = axes.plot(lambda x: np.cos(x), color=RED)
+
+        sin_label = axes.get_graph_label(
+            sin_graph, "\\sin(x)", x_val=-10, direction=UP / 2
+        )
+        cos_label = axes.get_graph_label(cos_graph, label="\\cos(x)")
+
+        vert_line = axes.get_vertical_line(
+            axes.i2gp(TAU, cos_graph), color=YELLOW, line_func=Line
+        )
+        line_label = axes.get_graph_label(
+            cos_graph, r"x=2\pi", x_val=TAU, direction=UR, color=WHITE
+        )
+
+        plot = VGroup(axes, sin_graph, cos_graph, vert_line)
+        labels = VGroup(axes_labels, sin_label, cos_label, line_label)
+        self.add(plot, labels)
+```
+
+<pre data-manim-binder data-manim-classname="SinAndCosFunctionPlot">
+class SinAndCosFunctionPlot(Scene):
+    def construct(self):
+        axes = Axes(
+            x_range=[-10, 10.3, 1],
+            y_range=[-1.5, 1.5, 1],
+            x_length=10,
+            axis_config={"color": GREEN},
+            x_axis_config={
+                "numbers_to_include": np.arange(-10, 10.01, 2),
+                "numbers_with_elongated_ticks": np.arange(-10, 10.01, 2),
+            },
+            tips=False,
+        )
+        axes_labels = axes.get_axis_labels()
+        sin_graph = axes.plot(lambda x: np.sin(x), color=BLUE)
+        cos_graph = axes.plot(lambda x: np.cos(x), color=RED)
+
+        sin_label = axes.get_graph_label(
+            sin_graph, "\\\\sin(x)", x_val=-10, direction=UP / 2
+        )
+        cos_label = axes.get_graph_label(cos_graph, label="\\\\cos(x)")
+
+        vert_line = axes.get_vertical_line(
+            axes.i2gp(TAU, cos_graph), color=YELLOW, line_func=Line
+        )
+        line_label = axes.get_graph_label(
+            cos_graph, r"x=2\\pi", x_val=TAU, direction=UR, color=WHITE
+        )
+
+        plot = VGroup(axes, sin_graph, cos_graph, vert_line)
+        labels = VGroup(axes_labels, sin_label, cos_label, line_label)
+        self.add(plot, labels)
+
+</pre>
+
+References: `coordinate_systems` [`MathTex`](reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) `plot()` `get_vertical_line_to_graph()` `input_to_graph_point()` [`get_axis_labels()`](reference/manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes.get_axis_labels)
+
+</div><div id="argminexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ArgMinExample <a class="headerlink" href="#argminexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ArgMinExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class ArgMinExample(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 10], y_range=[0, 100, 10], axis_config={"include_tip": False}
+        )
+        labels = ax.get_axis_labels(x_label="x", y_label="f(x)")
+
+        t = ValueTracker(0)
+
+        def func(x):
+            return 2 * (x - 5) ** 2
+        graph = ax.plot(func, color=MAROON)
+
+        initial_point = [ax.coords_to_point(t.get_value(), func(t.get_value()))]
+        dot = Dot(point=initial_point)
+
+        dot.add_updater(lambda x: x.move_to(ax.c2p(t.get_value(), func(t.get_value()))))
+        x_space = np.linspace(*ax.x_range[:2],200)
+        minimum_index = func(x_space).argmin()
+
+        self.add(ax, labels, graph, dot)
+        self.play(t.animate.set_value(x_space[minimum_index]))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="ArgMinExample">
+class ArgMinExample(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 10], y_range=[0, 100, 10], axis_config={"include_tip": False}
+        )
+        labels = ax.get_axis_labels(x_label="x", y_label="f(x)")
+
+        t = ValueTracker(0)
+
+        def func(x):
+            return 2 \* (x - 5) \*\* 2
+        graph = ax.plot(func, color=MAROON)
+
+        initial_point = [ax.coords_to_point(t.get_value(), func(t.get_value()))]
+        dot = Dot(point=initial_point)
+
+        dot.add_updater(lambda x: x.move_to(ax.c2p(t.get_value(), func(t.get_value()))))
+        x_space = np.linspace(\*ax.x_range[:2],200)
+        minimum_index = func(x_space).argmin()
+
+        self.add(ax, labels, graph, dot)
+        self.play(t.animate.set_value(x_space[minimum_index]))
+        self.wait()
+
+</pre></div><div id="graphareaplot" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GraphAreaPlot <a class="headerlink" href="#graphareaplot">¶</a></p>![image](media/images/GraphAreaPlot-1.png)
+```python
+from manim import *
+
+class GraphAreaPlot(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 5],
+            y_range=[0, 6],
+            x_axis_config={"numbers_to_include": [2, 3]},
+            tips=False,
+        )
+
+        labels = ax.get_axis_labels()
+
+        curve_1 = ax.plot(lambda x: 4 * x - x ** 2, x_range=[0, 4], color=BLUE_C)
+        curve_2 = ax.plot(
+            lambda x: 0.8 * x ** 2 - 3 * x + 4,
+            x_range=[0, 4],
+            color=GREEN_B,
+        )
+
+        line_1 = ax.get_vertical_line(ax.input_to_graph_point(2, curve_1), color=YELLOW)
+        line_2 = ax.get_vertical_line(ax.i2gp(3, curve_1), color=YELLOW)
+
+        riemann_area = ax.get_riemann_rectangles(curve_1, x_range=[0.3, 0.6], dx=0.03, color=BLUE, fill_opacity=0.5)
+        area = ax.get_area(curve_2, [2, 3], bounded_graph=curve_1, color=GREY, opacity=0.5)
+
+        self.add(ax, labels, curve_1, curve_2, line_1, line_2, riemann_area, area)
+```
+
+<pre data-manim-binder data-manim-classname="GraphAreaPlot">
+class GraphAreaPlot(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 5],
+            y_range=[0, 6],
+            x_axis_config={"numbers_to_include": [2, 3]},
+            tips=False,
+        )
+
+        labels = ax.get_axis_labels()
+
+        curve_1 = ax.plot(lambda x: 4 \* x - x \*\* 2, x_range=[0, 4], color=BLUE_C)
+        curve_2 = ax.plot(
+            lambda x: 0.8 \* x \*\* 2 - 3 \* x + 4,
+            x_range=[0, 4],
+            color=GREEN_B,
+        )
+
+        line_1 = ax.get_vertical_line(ax.input_to_graph_point(2, curve_1), color=YELLOW)
+        line_2 = ax.get_vertical_line(ax.i2gp(3, curve_1), color=YELLOW)
+
+        riemann_area = ax.get_riemann_rectangles(curve_1, x_range=[0.3, 0.6], dx=0.03, color=BLUE, fill_opacity=0.5)
+        area = ax.get_area(curve_2, [2, 3], bounded_graph=curve_1, color=GREY, opacity=0.5)
+
+        self.add(ax, labels, curve_1, curve_2, line_1, line_2, riemann_area, area)
+
+</pre>
+
+References: `coordinate_systems` `plot()` `get_vertical_line_to_graph()` `get_area()` [`get_axis_labels()`](reference/manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes.get_axis_labels)
+
+</div><div id="polygononaxes" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: PolygonOnAxes <a class="headerlink" href="#polygononaxes">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./PolygonOnAxes-1.mp4">
+</video>
+```python
+from manim import *
+
+class PolygonOnAxes(Scene):
+    def get_rectangle_corners(self, bottom_left, top_right):
+        return [
+            (top_right[0], top_right[1]),
+            (bottom_left[0], top_right[1]),
+            (bottom_left[0], bottom_left[1]),
+            (top_right[0], bottom_left[1]),
+        ]
+
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 10],
+            y_range=[0, 10],
+            x_length=6,
+            y_length=6,
+            axis_config={"include_tip": False},
+        )
+
+        t = ValueTracker(5)
+        k = 25
+
+        graph = ax.plot(
+            lambda x: k / x,
+            color=YELLOW_D,
+            x_range=[k / 10, 10.0, 0.01],
+            use_smoothing=False,
+        )
+
+        def get_rectangle():
+            polygon = Polygon(
+                *[
+                    ax.c2p(*i)
+                    for i in self.get_rectangle_corners(
+                        (0, 0), (t.get_value(), k / t.get_value())
+                    )
+                ]
+            )
+            polygon.stroke_width = 1
+            polygon.set_fill(BLUE, opacity=0.5)
+            polygon.set_stroke(YELLOW_B)
+            return polygon
+
+        polygon = always_redraw(get_rectangle)
+
+        dot = Dot()
+        dot.add_updater(lambda x: x.move_to(ax.c2p(t.get_value(), k / t.get_value())))
+        dot.set_z_index(10)
+
+        self.add(ax, graph, dot)
+        self.play(Create(polygon))
+        self.play(t.animate.set_value(10))
+        self.play(t.animate.set_value(k / 10))
+        self.play(t.animate.set_value(5))
+```
+
+<pre data-manim-binder data-manim-classname="PolygonOnAxes">
+class PolygonOnAxes(Scene):
+    def get_rectangle_corners(self, bottom_left, top_right):
+        return [
+            (top_right[0], top_right[1]),
+            (bottom_left[0], top_right[1]),
+            (bottom_left[0], bottom_left[1]),
+            (top_right[0], bottom_left[1]),
+        ]
+
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 10],
+            y_range=[0, 10],
+            x_length=6,
+            y_length=6,
+            axis_config={"include_tip": False},
+        )
+
+        t = ValueTracker(5)
+        k = 25
+
+        graph = ax.plot(
+            lambda x: k / x,
+            color=YELLOW_D,
+            x_range=[k / 10, 10.0, 0.01],
+            use_smoothing=False,
+        )
+
+        def get_rectangle():
+            polygon = Polygon(
+                \*[
+                    ax.c2p(\*i)
+                    for i in self.get_rectangle_corners(
+                        (0, 0), (t.get_value(), k / t.get_value())
+                    )
+                ]
+            )
+            polygon.stroke_width = 1
+            polygon.set_fill(BLUE, opacity=0.5)
+            polygon.set_stroke(YELLOW_B)
+            return polygon
+
+        polygon = always_redraw(get_rectangle)
+
+        dot = Dot()
+        dot.add_updater(lambda x: x.move_to(ax.c2p(t.get_value(), k / t.get_value())))
+        dot.set_z_index(10)
+
+        self.add(ax, graph, dot)
+        self.play(Create(polygon))
+        self.play(t.animate.set_value(10))
+        self.play(t.animate.set_value(k / 10))
+        self.play(t.animate.set_value(5))
+
+</pre>
+
+References: [`Axes`](reference/manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes) [`Polygon`](reference/manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon)
+
+</div><div id="heatdiagramplot" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: HeatDiagramPlot <a class="headerlink" href="#heatdiagramplot">¶</a></p>![image](media/images/HeatDiagramPlot-1.png)
+```python
+from manim import *
+
+class HeatDiagramPlot(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 40, 5],
+            y_range=[-8, 32, 5],
+            x_length=9,
+            y_length=6,
+            x_axis_config={"numbers_to_include": np.arange(0, 40, 5)},
+            y_axis_config={"numbers_to_include": np.arange(-5, 34, 5)},
+            tips=False,
+        )
+        labels = ax.get_axis_labels(
+            x_label=Tex(r"$\Delta Q$"), y_label=Tex(r"T[$^\circ C$]")
+        )
+
+        x_vals = [0, 8, 38, 39]
+        y_vals = [20, 0, 0, -5]
+        graph = ax.plot_line_graph(x_values=x_vals, y_values=y_vals)
+
+        self.add(ax, labels, graph)
+```
+
+<pre data-manim-binder data-manim-classname="HeatDiagramPlot">
+class HeatDiagramPlot(Scene):
+    def construct(self):
+        ax = Axes(
+            x_range=[0, 40, 5],
+            y_range=[-8, 32, 5],
+            x_length=9,
+            y_length=6,
+            x_axis_config={"numbers_to_include": np.arange(0, 40, 5)},
+            y_axis_config={"numbers_to_include": np.arange(-5, 34, 5)},
+            tips=False,
+        )
+        labels = ax.get_axis_labels(
+            x_label=Tex(r"$\\Delta Q$"), y_label=Tex(r"T[$^\\circ C$]")
+        )
+
+        x_vals = [0, 8, 38, 39]
+        y_vals = [20, 0, 0, -5]
+        graph = ax.plot_line_graph(x_values=x_vals, y_values=y_vals)
+
+        self.add(ax, labels, graph)
+
+</pre>
+
+References: `coordinate_systems` [`plot_line_graph()`](reference/manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes.plot_line_graph) [`get_axis_labels()`](reference/manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes.get_axis_labels)
+
+</div>
+
+## Special Camera Settings
+
+<div id="followinggraphcamera" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: FollowingGraphCamera <a class="headerlink" href="#followinggraphcamera">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./FollowingGraphCamera-1.mp4">
+</video>
+```python
+from manim import *
+
+class FollowingGraphCamera(MovingCameraScene):
+    def construct(self):
+        self.camera.frame.save_state()
+
+        # create the axes and the curve
+        ax = Axes(x_range=[-1, 10], y_range=[-1, 10])
+        graph = ax.plot(lambda x: np.sin(x), color=BLUE, x_range=[0, 3 * PI])
+
+        # create dots based on the graph
+        moving_dot = Dot(ax.i2gp(graph.t_min, graph), color=ORANGE)
+        dot_1 = Dot(ax.i2gp(graph.t_min, graph))
+        dot_2 = Dot(ax.i2gp(graph.t_max, graph))
+
+        self.add(ax, graph, dot_1, dot_2, moving_dot)
+        self.play(self.camera.frame.animate.scale(0.5).move_to(moving_dot))
+
+        def update_curve(mob):
+            mob.move_to(moving_dot.get_center())
+
+        self.camera.frame.add_updater(update_curve)
+        self.play(MoveAlongPath(moving_dot, graph, rate_func=linear))
+        self.camera.frame.remove_updater(update_curve)
+
+        self.play(Restore(self.camera.frame))
+```
+
+<pre data-manim-binder data-manim-classname="FollowingGraphCamera">
+class FollowingGraphCamera(MovingCameraScene):
+    def construct(self):
+        self.camera.frame.save_state()
+
+        # create the axes and the curve
+        ax = Axes(x_range=[-1, 10], y_range=[-1, 10])
+        graph = ax.plot(lambda x: np.sin(x), color=BLUE, x_range=[0, 3 \* PI])
+
+        # create dots based on the graph
+        moving_dot = Dot(ax.i2gp(graph.t_min, graph), color=ORANGE)
+        dot_1 = Dot(ax.i2gp(graph.t_min, graph))
+        dot_2 = Dot(ax.i2gp(graph.t_max, graph))
+
+        self.add(ax, graph, dot_1, dot_2, moving_dot)
+        self.play(self.camera.frame.animate.scale(0.5).move_to(moving_dot))
+
+        def update_curve(mob):
+            mob.move_to(moving_dot.get_center())
+
+        self.camera.frame.add_updater(update_curve)
+        self.play(MoveAlongPath(moving_dot, graph, rate_func=linear))
+        self.camera.frame.remove_updater(update_curve)
+
+        self.play(Restore(self.camera.frame))
+
+</pre>
+
+References: [`moving_camera_scene`](reference/manim.scene.moving_camera_scene.md#module-manim.scene.moving_camera_scene) [`MovingCameraScene`](reference/manim.scene.moving_camera_scene.MovingCameraScene.md#manim.scene.moving_camera_scene.MovingCameraScene) [`MoveAlongPath`](reference/manim.animation.movement.MoveAlongPath.md#manim.animation.movement.MoveAlongPath) [`Restore`](reference/manim.animation.transform.Restore.md#manim.animation.transform.Restore) `plot()` [`add_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater)
+
+</div><div id="movingzoomedscenearound" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MovingZoomedSceneAround <a class="headerlink" href="#movingzoomedscenearound">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./MovingZoomedSceneAround-1.mp4">
+</video>
+```python
+from manim import *
+
+class MovingZoomedSceneAround(ZoomedScene):
+# contributed by TheoremofBeethoven, www.youtube.com/c/TheoremofBeethoven
+    def __init__(self, **kwargs):
+        ZoomedScene.__init__(
+            self,
+            zoom_factor=0.3,
+            zoomed_display_height=1,
+            zoomed_display_width=6,
+            image_frame_stroke_width=20,
+            zoomed_camera_config={
+                "default_frame_stroke_width": 3,
+                },
+            **kwargs
+        )
+
+    def construct(self):
+        dot = Dot().shift(UL * 2)
+        image = ImageMobject(np.uint8([[0, 100, 30, 200],
+                                       [255, 0, 5, 33]]))
+        image.height = 7
+        frame_text = Text("Frame", color=PURPLE, font_size=67)
+        zoomed_camera_text = Text("Zoomed camera", color=RED, font_size=67)
+
+        self.add(image, dot)
+        zoomed_camera = self.zoomed_camera
+        zoomed_display = self.zoomed_display
+        frame = zoomed_camera.frame
+        zoomed_display_frame = zoomed_display.display_frame
+
+        frame.move_to(dot)
+        frame.set_color(PURPLE)
+        zoomed_display_frame.set_color(RED)
+        zoomed_display.shift(DOWN)
+
+        zd_rect = BackgroundRectangle(zoomed_display, fill_opacity=0, buff=MED_SMALL_BUFF)
+        self.add_foreground_mobject(zd_rect)
+
+        unfold_camera = UpdateFromFunc(zd_rect, lambda rect: rect.replace(zoomed_display))
+
+        frame_text.next_to(frame, DOWN)
+
+        self.play(Create(frame), FadeIn(frame_text, shift=UP))
+        self.activate_zooming()
+
+        self.play(self.get_zoomed_display_pop_out_animation(), unfold_camera)
+        zoomed_camera_text.next_to(zoomed_display_frame, DOWN)
+        self.play(FadeIn(zoomed_camera_text, shift=UP))
+        # Scale in        x   y  z
+        scale_factor = [0.5, 1.5, 0]
+        self.play(
+            frame.animate.scale(scale_factor),
+            zoomed_display.animate.scale(scale_factor),
+            FadeOut(zoomed_camera_text),
+            FadeOut(frame_text)
+        )
+        self.wait()
+        self.play(ScaleInPlace(zoomed_display, 2))
+        self.wait()
+        self.play(frame.animate.shift(2.5 * DOWN))
+        self.wait()
+        self.play(self.get_zoomed_display_pop_out_animation(), unfold_camera, rate_func=lambda t: smooth(1 - t))
+        self.play(Uncreate(zoomed_display_frame), FadeOut(frame))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="MovingZoomedSceneAround">
+class MovingZoomedSceneAround(ZoomedScene):
+# contributed by TheoremofBeethoven, www.youtube.com/c/TheoremofBeethoven
+    def \_\_init_\_(self, \*\*kwargs):
+        ZoomedScene._\_init_\_(
+            self,
+            zoom_factor=0.3,
+            zoomed_display_height=1,
+            zoomed_display_width=6,
+            image_frame_stroke_width=20,
+            zoomed_camera_config={
+                "default_frame_stroke_width": 3,
+                },
+            \*\*kwargs
+        )
+
+    def construct(self):
+        dot = Dot().shift(UL \* 2)
+        image = ImageMobject(np.uint8([[0, 100, 30, 200],
+                                       [255, 0, 5, 33]]))
+        image.height = 7
+        frame_text = Text("Frame", color=PURPLE, font_size=67)
+        zoomed_camera_text = Text("Zoomed camera", color=RED, font_size=67)
+
+        self.add(image, dot)
+        zoomed_camera = self.zoomed_camera
+        zoomed_display = self.zoomed_display
+        frame = zoomed_camera.frame
+        zoomed_display_frame = zoomed_display.display_frame
+
+        frame.move_to(dot)
+        frame.set_color(PURPLE)
+        zoomed_display_frame.set_color(RED)
+        zoomed_display.shift(DOWN)
+
+        zd_rect = BackgroundRectangle(zoomed_display, fill_opacity=0, buff=MED_SMALL_BUFF)
+        self.add_foreground_mobject(zd_rect)
+
+        unfold_camera = UpdateFromFunc(zd_rect, lambda rect: rect.replace(zoomed_display))
+
+        frame_text.next_to(frame, DOWN)
+
+        self.play(Create(frame), FadeIn(frame_text, shift=UP))
+        self.activate_zooming()
+
+        self.play(self.get_zoomed_display_pop_out_animation(), unfold_camera)
+        zoomed_camera_text.next_to(zoomed_display_frame, DOWN)
+        self.play(FadeIn(zoomed_camera_text, shift=UP))
+        # Scale in        x   y  z
+        scale_factor = [0.5, 1.5, 0]
+        self.play(
+            frame.animate.scale(scale_factor),
+            zoomed_display.animate.scale(scale_factor),
+            FadeOut(zoomed_camera_text),
+            FadeOut(frame_text)
+        )
+        self.wait()
+        self.play(ScaleInPlace(zoomed_display, 2))
+        self.wait()
+        self.play(frame.animate.shift(2.5 \* DOWN))
+        self.wait()
+        self.play(self.get_zoomed_display_pop_out_animation(), unfold_camera, rate_func=lambda t: smooth(1 - t))
+        self.play(Uncreate(zoomed_display_frame), FadeOut(frame))
+        self.wait()
+
+</pre>
+
+References: [`zoomed_scene`](reference/manim.scene.zoomed_scene.md#module-manim.scene.zoomed_scene) [`ZoomedScene`](reference/manim.scene.zoomed_scene.ZoomedScene.md#manim.scene.zoomed_scene.ZoomedScene) [`BackgroundRectangle`](reference/manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) [`UpdateFromFunc`](reference/manim.animation.updaters.update.UpdateFromFunc.md#manim.animation.updaters.update.UpdateFromFunc) [`add_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) [`get_zoomed_display_pop_out_animation()`](reference/manim.scene.zoomed_scene.ZoomedScene.md#manim.scene.zoomed_scene.ZoomedScene.get_zoomed_display_pop_out_animation)
+
+</div><div id="fixedinframemobjecttest" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: FixedInFrameMObjectTest <a class="headerlink" href="#fixedinframemobjecttest">¶</a></p>![image](media/images/FixedInFrameMObjectTest-1.png)
+```python
+from manim import *
+
+class FixedInFrameMObjectTest(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        self.set_camera_orientation(phi=75 * DEGREES, theta=-45 * DEGREES)
+        text3d = Text("This is a 3D text")
+        self.add_fixed_in_frame_mobjects(text3d)
+        text3d.to_corner(UL)
+        self.add(axes)
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="FixedInFrameMObjectTest">
+class FixedInFrameMObjectTest(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        self.set_camera_orientation(phi=75 \* DEGREES, theta=-45 \* DEGREES)
+        text3d = Text("This is a 3D text")
+        self.add_fixed_in_frame_mobjects(text3d)
+        text3d.to_corner(UL)
+        self.add(axes)
+        self.wait()
+
+</pre>
+
+References: [`ThreeDScene`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) [`set_camera_orientation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.set_camera_orientation) [`add_fixed_in_frame_mobjects()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.add_fixed_in_frame_mobjects)
+
+</div><div id="threedlightsourceposition" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ThreeDLightSourcePosition <a class="headerlink" href="#threedlightsourceposition">¶</a></p>![image](media/images/ThreeDLightSourcePosition-1.png)
+```python
+from manim import *
+
+class ThreeDLightSourcePosition(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        sphere = Surface(
+            lambda u, v: np.array([
+                1.5 * np.cos(u) * np.cos(v),
+                1.5 * np.cos(u) * np.sin(v),
+                1.5 * np.sin(u)
+            ]), v_range=[0, TAU], u_range=[-PI / 2, PI / 2],
+            checkerboard_colors=[RED_D, RED_E], resolution=(15, 32)
+        )
+        self.renderer.camera.light_source.move_to(3*IN) # changes the source of the light
+        self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+        self.add(axes, sphere)
+```
+
+<pre data-manim-binder data-manim-classname="ThreeDLightSourcePosition">
+class ThreeDLightSourcePosition(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        sphere = Surface(
+            lambda u, v: np.array([
+                1.5 \* np.cos(u) \* np.cos(v),
+                1.5 \* np.cos(u) \* np.sin(v),
+                1.5 \* np.sin(u)
+            ]), v_range=[0, TAU], u_range=[-PI / 2, PI / 2],
+            checkerboard_colors=[RED_D, RED_E], resolution=(15, 32)
+        )
+        self.renderer.camera.light_source.move_to(3\*IN) # changes the source of the light
+        self.set_camera_orientation(phi=75 \* DEGREES, theta=30 \* DEGREES)
+        self.add(axes, sphere)
+
+</pre>
+
+References: [`ThreeDScene`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) [`ThreeDAxes`](reference/manim.mobject.graphing.coordinate_systems.ThreeDAxes.md#manim.mobject.graphing.coordinate_systems.ThreeDAxes) [`Surface`](reference/manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface) [`set_camera_orientation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.set_camera_orientation)
+
+</div><div id="threedcamerarotation" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ThreeDCameraRotation <a class="headerlink" href="#threedcamerarotation">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ThreeDCameraRotation-1.mp4">
+</video>
+```python
+from manim import *
+
+class ThreeDCameraRotation(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        circle=Circle()
+        self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+        self.add(circle,axes)
+        self.begin_ambient_camera_rotation(rate=0.1)
+        self.wait()
+        self.stop_ambient_camera_rotation()
+        self.move_camera(phi=75 * DEGREES, theta=30 * DEGREES)
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="ThreeDCameraRotation">
+class ThreeDCameraRotation(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        circle=Circle()
+        self.set_camera_orientation(phi=75 \* DEGREES, theta=30 \* DEGREES)
+        self.add(circle,axes)
+        self.begin_ambient_camera_rotation(rate=0.1)
+        self.wait()
+        self.stop_ambient_camera_rotation()
+        self.move_camera(phi=75 \* DEGREES, theta=30 \* DEGREES)
+        self.wait()
+
+</pre>
+
+References: [`ThreeDScene`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) [`ThreeDAxes`](reference/manim.mobject.graphing.coordinate_systems.ThreeDAxes.md#manim.mobject.graphing.coordinate_systems.ThreeDAxes) [`begin_ambient_camera_rotation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.begin_ambient_camera_rotation) [`stop_ambient_camera_rotation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.stop_ambient_camera_rotation)
+
+</div><div id="threedcameraillusionrotation" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ThreeDCameraIllusionRotation <a class="headerlink" href="#threedcameraillusionrotation">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ThreeDCameraIllusionRotation-1.mp4">
+</video>
+```python
+from manim import *
+
+class ThreeDCameraIllusionRotation(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        circle=Circle()
+        self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+        self.add(circle,axes)
+        self.begin_3dillusion_camera_rotation(rate=2)
+        self.wait(PI/2)
+        self.stop_3dillusion_camera_rotation()
+```
+
+<pre data-manim-binder data-manim-classname="ThreeDCameraIllusionRotation">
+class ThreeDCameraIllusionRotation(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        circle=Circle()
+        self.set_camera_orientation(phi=75 \* DEGREES, theta=30 \* DEGREES)
+        self.add(circle,axes)
+        self.begin_3dillusion_camera_rotation(rate=2)
+        self.wait(PI/2)
+        self.stop_3dillusion_camera_rotation()
+
+</pre>
+
+References: [`ThreeDScene`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) [`ThreeDAxes`](reference/manim.mobject.graphing.coordinate_systems.ThreeDAxes.md#manim.mobject.graphing.coordinate_systems.ThreeDAxes) [`begin_3dillusion_camera_rotation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.begin_3dillusion_camera_rotation) [`stop_3dillusion_camera_rotation()`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene.stop_3dillusion_camera_rotation)
+
+</div><div id="threedsurfaceplot" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ThreeDSurfacePlot <a class="headerlink" href="#threedsurfaceplot">¶</a></p>![image](media/images/ThreeDSurfacePlot-1.png)
+```python
+from manim import *
+
+class ThreeDSurfacePlot(ThreeDScene):
+    def construct(self):
+        resolution_fa = 24
+        self.set_camera_orientation(phi=75 * DEGREES, theta=-30 * DEGREES)
+
+        def param_gauss(u, v):
+            x = u
+            y = v
+            sigma, mu = 0.4, [0.0, 0.0]
+            d = np.linalg.norm(np.array([x - mu[0], y - mu[1]]))
+            z = np.exp(-(d ** 2 / (2.0 * sigma ** 2)))
+            return np.array([x, y, z])
+
+        gauss_plane = Surface(
+            param_gauss,
+            resolution=(resolution_fa, resolution_fa),
+            v_range=[-2, +2],
+            u_range=[-2, +2]
+        )
+
+        gauss_plane.scale(2, about_point=ORIGIN)
+        gauss_plane.set_style(fill_opacity=1,stroke_color=GREEN)
+        gauss_plane.set_fill_by_checkerboard(ORANGE, BLUE, opacity=0.5)
+        axes = ThreeDAxes()
+        self.add(axes,gauss_plane)
+```
+
+<pre data-manim-binder data-manim-classname="ThreeDSurfacePlot">
+class ThreeDSurfacePlot(ThreeDScene):
+    def construct(self):
+        resolution_fa = 24
+        self.set_camera_orientation(phi=75 \* DEGREES, theta=-30 \* DEGREES)
+
+        def param_gauss(u, v):
+            x = u
+            y = v
+            sigma, mu = 0.4, [0.0, 0.0]
+            d = np.linalg.norm(np.array([x - mu[0], y - mu[1]]))
+            z = np.exp(-(d \*\* 2 / (2.0 \* sigma \*\* 2)))
+            return np.array([x, y, z])
+
+        gauss_plane = Surface(
+            param_gauss,
+            resolution=(resolution_fa, resolution_fa),
+            v_range=[-2, +2],
+            u_range=[-2, +2]
+        )
+
+        gauss_plane.scale(2, about_point=ORIGIN)
+        gauss_plane.set_style(fill_opacity=1,stroke_color=GREEN)
+        gauss_plane.set_fill_by_checkerboard(ORANGE, BLUE, opacity=0.5)
+        axes = ThreeDAxes()
+        self.add(axes,gauss_plane)
+
+</pre>
+
+References: [`ThreeDScene`](reference/manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) [`Surface`](reference/manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+</div>
+
+## Advanced Projects
+
+<div id="openingmanim" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: OpeningManim <a class="headerlink" href="#openingmanim">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./OpeningManim-1.mp4">
+</video>
+```python
+from manim import *
+
+class OpeningManim(Scene):
+    def construct(self):
+        title = Tex(r"This is some \LaTeX")
+        basel = MathTex(r"\sum_{n=1}^\infty \frac{1}{n^2} = \frac{\pi^2}{6}")
+        VGroup(title, basel).arrange(DOWN)
+        self.play(
+            Write(title),
+            FadeIn(basel, shift=DOWN),
+        )
+        self.wait()
+
+        transform_title = Tex("That was a transform")
+        transform_title.to_corner(UP + LEFT)
+        self.play(
+            Transform(title, transform_title),
+            LaggedStart(*[FadeOut(obj, shift=DOWN) for obj in basel]),
+        )
+        self.wait()
+
+        grid = NumberPlane()
+        grid_title = Tex("This is a grid", font_size=72)
+        grid_title.move_to(transform_title)
+
+        self.add(grid, grid_title)  # Make sure title is on top of grid
+        self.play(
+            FadeOut(title),
+            FadeIn(grid_title, shift=UP),
+            Create(grid, run_time=3, lag_ratio=0.1),
+        )
+        self.wait()
+
+        grid_transform_title = Tex(
+            r"That was a non-linear function \\ applied to the grid"
+        )
+        grid_transform_title.move_to(grid_title, UL)
+        grid.prepare_for_nonlinear_transform()
+        self.play(
+            grid.animate.apply_function(
+                lambda p: p
+                          + np.array(
+                    [
+                        np.sin(p[1]),
+                        np.sin(p[0]),
+                        0,
+                    ]
+                )
+            ),
+            run_time=3,
+        )
+        self.wait()
+        self.play(Transform(grid_title, grid_transform_title))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="OpeningManim">
+class OpeningManim(Scene):
+    def construct(self):
+        title = Tex(r"This is some \\LaTeX")
+        basel = MathTex(r"\\sum_{n=1}^\\infty \\frac{1}{n^2} = \\frac{\\pi^2}{6}")
+        VGroup(title, basel).arrange(DOWN)
+        self.play(
+            Write(title),
+            FadeIn(basel, shift=DOWN),
+        )
+        self.wait()
+
+        transform_title = Tex("That was a transform")
+        transform_title.to_corner(UP + LEFT)
+        self.play(
+            Transform(title, transform_title),
+            LaggedStart(\*[FadeOut(obj, shift=DOWN) for obj in basel]),
+        )
+        self.wait()
+
+        grid = NumberPlane()
+        grid_title = Tex("This is a grid", font_size=72)
+        grid_title.move_to(transform_title)
+
+        self.add(grid, grid_title)  # Make sure title is on top of grid
+        self.play(
+            FadeOut(title),
+            FadeIn(grid_title, shift=UP),
+            Create(grid, run_time=3, lag_ratio=0.1),
+        )
+        self.wait()
+
+        grid_transform_title = Tex(
+            r"That was a non-linear function \\\\ applied to the grid"
+        )
+        grid_transform_title.move_to(grid_title, UL)
+        grid.prepare_for_nonlinear_transform()
+        self.play(
+            grid.animate.apply_function(
+                lambda p: p
+                          + np.array(
+                    [
+                        np.sin(p[1]),
+                        np.sin(p[0]),
+                        0,
+                    ]
+                )
+            ),
+            run_time=3,
+        )
+        self.wait()
+        self.play(Transform(grid_title, grid_transform_title))
+        self.wait()
+
+</pre>
+
+References: [`Tex`](reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) [`MathTex`](reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) [`Write`](reference/manim.animation.creation.Write.md#manim.animation.creation.Write) [`FadeIn`](reference/manim.animation.fading.FadeIn.md#manim.animation.fading.FadeIn) [`LaggedStart`](reference/manim.animation.composition.LaggedStart.md#manim.animation.composition.LaggedStart) [`NumberPlane`](reference/manim.mobject.graphing.coordinate_systems.NumberPlane.md#manim.mobject.graphing.coordinate_systems.NumberPlane) [`Create`](reference/manim.animation.creation.Create.md#manim.animation.creation.Create) `prepare_for_nonlinear_transform()`
+
+</div><div id="sinecurveunitcircle" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SineCurveUnitCircle <a class="headerlink" href="#sinecurveunitcircle">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./SineCurveUnitCircle-1.mp4">
+</video>
+```python
+from manim import *
+
+class SineCurveUnitCircle(Scene):
+    # contributed by heejin_park, https://infograph.tistory.com/230
+    def construct(self):
+        self.show_axis()
+        self.show_circle()
+        self.move_dot_and_draw_curve()
+        self.wait()
+
+    def show_axis(self):
+        x_start = np.array([-6,0,0])
+        x_end = np.array([6,0,0])
+
+        y_start = np.array([-4,-2,0])
+        y_end = np.array([-4,2,0])
+
+        x_axis = Line(x_start, x_end)
+        y_axis = Line(y_start, y_end)
+
+        self.add(x_axis, y_axis)
+        self.add_x_labels()
+
+        self.origin_point = np.array([-4,0,0])
+        self.curve_start = np.array([-3,0,0])
+
+    def add_x_labels(self):
+        x_labels = [
+            MathTex(r"\pi"), MathTex(r"2 \pi"),
+            MathTex(r"3 \pi"), MathTex(r"4 \pi"),
+        ]
+
+        for i in range(len(x_labels)):
+            x_labels[i].next_to(np.array([-1 + 2*i, 0, 0]), DOWN)
+            self.add(x_labels[i])
+
+    def show_circle(self):
+        circle = Circle(radius=1)
+        circle.move_to(self.origin_point)
+        self.add(circle)
+        self.circle = circle
+
+    def move_dot_and_draw_curve(self):
+        orbit = self.circle
+        origin_point = self.origin_point
+
+        dot = Dot(radius=0.08, color=YELLOW)
+        dot.move_to(orbit.point_from_proportion(0))
+        self.t_offset = 0
+        rate = 0.25
+
+        def go_around_circle(mob, dt):
+            self.t_offset += (dt * rate)
+            # print(self.t_offset)
+            mob.move_to(orbit.point_from_proportion(self.t_offset % 1))
+
+        def get_line_to_circle():
+            return Line(origin_point, dot.get_center(), color=BLUE)
+
+        def get_line_to_curve():
+            x = self.curve_start[0] + self.t_offset * 4
+            y = dot.get_center()[1]
+            return Line(dot.get_center(), np.array([x,y,0]), color=YELLOW_A, stroke_width=2 )
+
+
+        self.curve = VGroup()
+        self.curve.add(Line(self.curve_start,self.curve_start))
+        def get_curve():
+            last_line = self.curve[-1]
+            x = self.curve_start[0] + self.t_offset * 4
+            y = dot.get_center()[1]
+            new_line = Line(last_line.get_end(),np.array([x,y,0]), color=YELLOW_D)
+            self.curve.add(new_line)
+
+            return self.curve
+
+        dot.add_updater(go_around_circle)
+
+        origin_to_circle_line = always_redraw(get_line_to_circle)
+        dot_to_curve_line = always_redraw(get_line_to_curve)
+        sine_curve_line = always_redraw(get_curve)
+
+        self.add(dot)
+        self.add(orbit, origin_to_circle_line, dot_to_curve_line, sine_curve_line)
+        self.wait(8.5)
+
+        dot.remove_updater(go_around_circle)
+```
+
+<pre data-manim-binder data-manim-classname="SineCurveUnitCircle">
+class SineCurveUnitCircle(Scene):
+    # contributed by heejin_park, https://infograph.tistory.com/230
+    def construct(self):
+        self.show_axis()
+        self.show_circle()
+        self.move_dot_and_draw_curve()
+        self.wait()
+
+    def show_axis(self):
+        x_start = np.array([-6,0,0])
+        x_end = np.array([6,0,0])
+
+        y_start = np.array([-4,-2,0])
+        y_end = np.array([-4,2,0])
+
+        x_axis = Line(x_start, x_end)
+        y_axis = Line(y_start, y_end)
+
+        self.add(x_axis, y_axis)
+        self.add_x_labels()
+
+        self.origin_point = np.array([-4,0,0])
+        self.curve_start = np.array([-3,0,0])
+
+    def add_x_labels(self):
+        x_labels = [
+            MathTex(r"\\pi"), MathTex(r"2 \\pi"),
+            MathTex(r"3 \\pi"), MathTex(r"4 \\pi"),
+        ]
+
+        for i in range(len(x_labels)):
+            x_labels[i].next_to(np.array([-1 + 2\*i, 0, 0]), DOWN)
+            self.add(x_labels[i])
+
+    def show_circle(self):
+        circle = Circle(radius=1)
+        circle.move_to(self.origin_point)
+        self.add(circle)
+        self.circle = circle
+
+    def move_dot_and_draw_curve(self):
+        orbit = self.circle
+        origin_point = self.origin_point
+
+        dot = Dot(radius=0.08, color=YELLOW)
+        dot.move_to(orbit.point_from_proportion(0))
+        self.t_offset = 0
+        rate = 0.25
+
+        def go_around_circle(mob, dt):
+            self.t_offset += (dt \* rate)
+            # print(self.t_offset)
+            mob.move_to(orbit.point_from_proportion(self.t_offset % 1))
+
+        def get_line_to_circle():
+            return Line(origin_point, dot.get_center(), color=BLUE)
+
+        def get_line_to_curve():
+            x = self.curve_start[0] + self.t_offset \* 4
+            y = dot.get_center()[1]
+            return Line(dot.get_center(), np.array([x,y,0]), color=YELLOW_A, stroke_width=2 )
+
+
+        self.curve = VGroup()
+        self.curve.add(Line(self.curve_start,self.curve_start))
+        def get_curve():
+            last_line = self.curve[-1]
+            x = self.curve_start[0] + self.t_offset \* 4
+            y = dot.get_center()[1]
+            new_line = Line(last_line.get_end(),np.array([x,y,0]), color=YELLOW_D)
+            self.curve.add(new_line)
+
+            return self.curve
+
+        dot.add_updater(go_around_circle)
+
+        origin_to_circle_line = always_redraw(get_line_to_circle)
+        dot_to_curve_line = always_redraw(get_line_to_curve)
+        sine_curve_line = always_redraw(get_curve)
+
+        self.add(dot)
+        self.add(orbit, origin_to_circle_line, dot_to_curve_line, sine_curve_line)
+        self.wait(8.5)
+
+        dot.remove_updater(go_around_circle)
+
+</pre>
+
+References: [`MathTex`](reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) [`Circle`](reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) [`Dot`](reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) [`Line`](reference/manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) [`VGroup`](reference/manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) [`always_redraw()`](reference/manim.animation.updaters.mobject_update_utils.md#manim.animation.updaters.mobject_update_utils.always_redraw) [`add_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) [`remove_updater()`](reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.remove_updater)
+
+</div>

data/rag/manim_docs/manim_core/docs/guides/add_voiceovers.md

@@ -0,0 +1,63 @@
+# Adding Voiceovers to Videos
+
+Creating a full-fledged video with voiceovers is a bit more involved than
+creating purely visual Manim scenes. One has to use [a video editing
+program](https://en.wikipedia.org/wiki/List_of_video_editing_software)
+to add the voiceovers after the video has been rendered. This process
+can be difficult and time-consuming, since it requires a lot of planning
+and preparation.
+
+To ease the process of adding voiceovers to videos, we have created
+[Manim Voiceover](https://voiceover.manim.community), a plugin
+that lets you add voiceovers to scenes directly in Python. To install it, run
+
+```bash
+pip install "manim-voiceover[azure,gtts]"
+```
+
+Visit [the installation page](https://voiceover.manim.community/en/latest/installation.html)
+for more details on how to install Manim Voiceover.
+
+## Basic Usage
+
+Manim Voiceover lets you …
+
+- Add voiceovers to Manim videos directly in Python, without having to use a video editor.
+- Record voiceovers with your microphone during rendering through a simple command line interface.
+- Develop animations with auto-generated AI voices from various free and proprietary services.
+
+It provides a very simple API that lets you specify your voiceover script
+and then record it during rendering:
+
+```python
+from manim import *
+from manim_voiceover import VoiceoverScene
+from manim_voiceover.services.recorder import RecorderService
+
+
+# Simply inherit from VoiceoverScene instead of Scene to get all the
+# voiceover functionality.
+class RecorderExample(VoiceoverScene):
+    def construct(self):
+        # You can choose from a multitude of TTS services,
+        # or in this example, record your own voice:
+        self.set_speech_service(RecorderService())
+
+        circle = Circle()
+
+        # Surround animation sections with with-statements:
+        with self.voiceover(text="This circle is drawn as I speak.") as tracker:
+            self.play(Create(circle), run_time=tracker.duration)
+            # The duration of the animation is received from the audio file
+            # and passed to the tracker automatically.
+
+        # This part will not start playing until the previous voiceover is finished.
+        with self.voiceover(text="Let's shift it to the left 2 units.") as tracker:
+            self.play(circle.animate.shift(2 * LEFT), run_time=tracker.duration)
+```
+
+To get started with Manim Voiceover,
+visit the [Quick Start Guide](https://voiceover.manim.community/en/latest/quickstart.html).
+
+Visit the [Example Gallery](https://voiceover.manim.community/en/latest/examples.html)
+to see some examples of Manim Voiceover in action.

data/rag/manim_docs/manim_core/docs/guides/deep_dive.md

@@ -0,0 +1,1004 @@
+# A deep dive into Manim’s internals
+
+**Author:** [Benjamin Hackl](https://benjamin-hackl.at)
+
+## Introduction
+
+Manim can be a wonderful library, if it behaves the way you would like it to,
+and/or the way you expect it to. Unfortunately, this is not always the case
+(as you probably know if you have played with some manimations yourself already).
+To understand where things *go wrong*, digging through the library’s source code
+is sometimes the only option – but in order to do that, you need to know where
+to start digging.
+
+This article is intended as some sort of life line through the render process.
+We aim to give an appropriate amount of detail describing what happens when
+Manim reads your scene code and produces the corresponding animation. Throughout
+this article, we will focus on the following toy example:
+
+```default
+from manim import *
+
+class ToyExample(Scene):
+    def construct(self):
+        orange_square = Square(color=ORANGE, fill_opacity=0.5)
+        blue_circle = Circle(color=BLUE, fill_opacity=0.5)
+        self.add(orange_square)
+        self.play(ReplacementTransform(orange_square, blue_circle, run_time=3))
+        small_dot = Dot()
+        small_dot.add_updater(lambda mob: mob.next_to(blue_circle, DOWN))
+        self.play(Create(small_dot))
+        self.play(blue_circle.animate.shift(RIGHT))
+        self.wait()
+        self.play(FadeOut(blue_circle, small_dot))
+```
+
+Before we go into details or even look at the rendered output of this scene,
+let us first describe verbally what happens in this *manimation*. In the first
+three lines of the `construct` method, a [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square) and a [`Circle`](../reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+are initialized, then the square is added to the scene. The first frame of the
+rendered output should thus show an orange square.
+
+Then the actual animations happen: the square first transforms into a circle,
+then a [`Dot`](../reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) is created (Where do you guess the dot is located when
+it is first added to the scene? Answering this already requires detailed
+knowledge about the render process.). The dot has an updater attached to it, and
+as the circle moves right, the dot moves with it. In the end, all mobjects are
+faded out.
+
+Actually rendering the code yields the following video:
+
+<video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ToyExample-1.mp4">
+</video>
+
+For this example, the output (fortunately) coincides with our expectations.
+
+## Overview
+
+Because there is a lot of information in this article, here is a brief overview
+discussing the contents of the following chapters on a very high level.
+
+- [Preliminaries](): In this chapter we unravel all the steps that take place
+  to prepare a scene for rendering; right until the point where the user-overridden
+  `construct` method is ran. This includes a brief discussion on using Manim’s CLI
+  versus other means of rendering (e.g., via Jupyter notebooks, or in your Python
+  script by calling the [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) method yourself).
+- [Mobject Initialization](): For the second chapter we dive into creating and handling
+  Mobjects, the basic elements that should be displayed in our scene.
+  We discuss the [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) base class, how there are essentially
+  three different types of Mobjects, and then discuss the most important of them,
+  vectorized Mobjects. In particular, we describe the internal point data structure
+  that governs how the mechanism responsible for drawing the vectorized Mobject
+  to the screen sets the corresponding Bézier curves. We conclude the chapter
+  with a tour into [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add), the bookkeeping mechanism controlling which
+  mobjects should be rendered.
+- [Animations and the Render Loop](): And finally, in the last chapter we walk
+  through the instantiation of [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects (the blueprints that
+  hold information on how Mobjects should be modified when the render loop runs),
+  followed by a investigation of the infamous [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call. We will
+  see that there are three relevant parts in a [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call;
+  a part in which the passed animations and keyword arguments are processed
+  and prepared, followed by the actual “render loop” in which the library
+  steps through a time line and renders frame by frame. The final part
+  does some post-processing to save a short video segment (“partial movie file”)
+  and cleanup for the next call to [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play). In the end, after all of
+  [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) has been run, the library combines the partial movie
+  files to one video.
+
+And with that, let us get *in medias res*.
+
+## Preliminaries
+
+### Importing the library
+
+Independent of how exactly you are telling your system
+to render the scene, i.e., whether you run `manim -qm -p file_name.py ToyExample`, or
+whether you are rendering the scene directly from the Python script via a snippet
+like
+
+```default
+with tempconfig({"quality": "medium_quality", "preview": True}):
+    scene = ToyExample()
+    scene.render()
+```
+
+or whether you are rendering the code in a Jupyter notebook, you are still telling your
+python interpreter to import the library. The usual pattern used to do this is
+
+```default
+from manim import *
+```
+
+which (while being a debatable strategy in general) imports a lot of classes and
+functions shipped with the library and makes them available in your global name space.
+I explicitly avoided stating that it imports **all** classes and functions of the
+library, because it does not do that: Manim makes use of the practice described
+in [Section 6.4.1 of the Python tutorial](https://docs.python.org/3/tutorial/modules.html#importing-from-a-package),
+and all module members that should be exposed to the user upon running the `*`-import
+are explicitly declared in the `__all__` variable of the module.
+
+Manim also uses this strategy internally: taking a peek at the file that is run when
+the import is called, `__init__.py` (see
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/__init__.py)),
+you will notice that most of the code in that module is concerned with importing
+members from various different submodules, again using `*`-imports.
+
+In that file, there is one particular import at the beginning of the file however,
+namely:
+
+```default
+from ._config import *
+```
+
+This initializes Manim’s global configuration system, which is used in various places
+throughout the library. After the library runs this line, the current configuration
+options are set. The code in there takes care of reading the options in your `.cfg`
+files (all users have at least the global one that is shipped with the library)
+as well as correctly handling command line arguments (if you used the CLI to render).
+
+You can read more about the config system in the
+[corresponding thematic guide](configuration.md), and if you are interested in learning
+more about the internals of the configuration system and how it is initialized,
+follow the code flow starting in [the config module’s init file](https://github.com/ManimCommunity/manim/blob/main/manim/_config/__init__.py).
+
+Now that the library is imported, we can turn our attention to the next step:
+reading your scene code (which is not particularly exciting, Python just creates
+a new class `ToyExample` based on our code; Manim is virtually not involved
+in that step, with the exception that `ToyExample` inherits from `Scene`).
+
+However, with the `ToyExample` class created and ready to go, there is a new
+excellent question to answer: how is the code in our `construct` method
+actually executed?
+
+### Scene instantiation and rendering
+
+The answer to this question depends on how exactly you are running the code.
+To make things a bit clearer, let us first consider the case that you
+have created a file `toy_example.py` which looks like this:
+
+```default
+from manim import *
+
+class ToyExample(Scene):
+    def construct(self):
+        orange_square = Square(color=ORANGE, fill_opacity=0.5)
+        blue_circle = Circle(color=BLUE, fill_opacity=0.5)
+        self.add(orange_square)
+        self.play(ReplacementTransform(orange_square, blue_circle, run_time=3))
+        small_dot = Dot()
+        small_dot.add_updater(lambda mob: mob.next_to(blue_circle, DOWN))
+        self.play(Create(small_dot))
+        self.play(blue_circle.animate.shift(RIGHT))
+        self.wait()
+        self.play(FadeOut(blue_circle, small_dot))
+
+with tempconfig({"quality": "medium_quality", "preview": True}):
+    scene = ToyExample()
+    scene.render()
+```
+
+With such a file, the desired scene is rendered by simply running this Python
+script via `python toy_example.py`. Then, as described above, the library
+is imported and Python has read and defined the `ToyExample` class (but,
+read carefully: *no instance of this class has been created yet*).
+
+At this point, the interpreter is about to enter the `tempconfig` context
+manager. Even if you have not seen Manim’s `tempconfig` before, its name
+already suggests what it does: it creates a copy of the current state of the
+configuration, applies the changes to the key-value pairs in the passed
+dictionary, and upon leaving the context the original version of the
+configuration is restored. TL;DR: it provides a fancy way of temporarily setting
+configuration options.
+
+Inside the context manager, two things happen: an actual `ToyExample`-scene
+object is instantiated, and the `render` method is called. Every way of using
+Manim ultimately does something along of these lines, the library always instantiates
+the scene object and then calls its `render` method. To illustrate that this
+really is the case, let us briefly look at the two most common ways of rendering
+scenes:
+
+**Command Line Interface.** When using the CLI and running the command
+`manim -qm -p toy_example.py ToyExample` in your terminal, the actual
+entry point is Manim’s `__main__.py` file (located
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/__main__.py).
+Manim uses [Click](https://click.palletsprojects.com/en/8.0.x/) to implement
+the command line interface, and the corresponding code is located in Manim’s
+`cli` module ([https://github.com/ManimCommunity/manim/tree/main/manim/cli](https://github.com/ManimCommunity/manim/tree/main/manim/cli)).
+The corresponding code creating the scene class and calling its render method
+is located [here](https://github.com/ManimCommunity/manim/blob/ac1ee9a683ce8b92233407351c681f7d71a4f2db/manim/cli/render/commands.py#L139-L141).
+
+**Jupyter notebooks.** In Jupyter notebooks, the communication with the library
+is handled by the `%%manim` magic command, which is implemented in the
+`manim.utils.ipython_magic` module. There is
+[`some documentation`](../reference/manim.utils.ipython_magic.ManimMagic.md#manim.utils.ipython_magic.ManimMagic.manim) available for the magic command,
+and the code creating the scene class and calling its render method is located
+[here](https://github.com/ManimCommunity/manim/blob/ac1ee9a683ce8b92233407351c681f7d71a4f2db/manim/utils/ipython_magic.py#L137-L138).
+
+Now that we know that either way, a [`Scene`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene) object is created, let us investigate
+what Manim does when that happens. When instantiating our scene object
+
+```default
+scene = ToyExample()
+```
+
+the `Scene.__init__` method is called, given that we did not implement our own initialization
+method. Inspecting the corresponding code (see
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/scene/scene.py))
+reveals that `Scene.__init__` first sets several attributes of the scene objects that do not
+depend on any configuration options set in `config`. Then the scene inspects the value of
+`config.renderer`, and based on its value, either instantiates a `CairoRenderer` or an
+`OpenGLRenderer` object and assigns it to its `renderer` attribute.
+
+The scene then asks its renderer to initialize the scene by calling
+
+```default
+self.renderer.init_scene(self)
+```
+
+Inspecting both the default Cairo renderer and the OpenGL renderer shows that the `init_scene`
+method effectively makes the renderer instantiate a [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) object, which
+basically is Manim’s interface to `libav` (FFMPEG) and actually writes the movie file. The Cairo
+renderer (see the implementation [here](https://github.com/ManimCommunity/manim/blob/main/manim/renderer/cairo_renderer.py)) does not require any further initialization. The OpenGL renderer
+does some additional setup to enable the realtime rendering preview window, which we do not go
+into detail further here.
+
+#### WARNING
+Currently, there is a lot of interplay between a scene and its renderer. This is a flaw
+in Manim’s current architecture, and we are working on reducing this interdependency to
+achieve a less convoluted code flow.
+
+After the renderer has been instantiated and initialized its file writer, the scene populates
+further initial attributes (notable mention: the `mobjects` attribute which keeps track
+of the mobjects that have been added to the scene). It is then done with its instantiation
+and ready to be rendered.
+
+The rest of this article is concerned with the last line in our toy example script:
+
+```default
+scene.render()
+```
+
+This is where the actual magic happens.
+
+Inspecting the [implementation of the render method](https://github.com/ManimCommunity/manim/blob/df1a60421ea1119cbbbd143ef288d294851baaac/manim/scene/scene.py#L211)
+reveals that there are several hooks that can be used for pre- or postprocessing
+a scene. Unsurprisingly, [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) describes the full *render cycle*
+of a scene. During this life cycle, there are three custom methods whose base
+implementation is empty and that can be overwritten to suit your purposes. In
+the order they are called, these customizable methods are:
+
+- [`Scene.setup()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.setup), which is intended for preparing and, well, *setting up*
+  the scene for your animation (e.g., adding initial mobjects, assigning custom
+  attributes to your scene class, etc.),
+- [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct), which is the *script* for your screen play and
+  contains programmatic descriptions of your animations, and
+- [`Scene.tear_down()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.tear_down), which is intended for any operations you might
+  want to run on the scene after the last frame has already been rendered
+  (for example, this could run some code that generates a custom thumbnail
+  for the video based on the state of the objects in the scene – this
+  hook is more relevant for situations where Manim is used within other
+  Python scripts).
+
+After these three methods are run, the animations have been fully rendered,
+and Manim calls `CairoRenderer.scene_finished()` to gracefully
+complete the rendering process. This checks whether any animations have been
+played – and if so, it tells the [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to close the output
+file. If not, Manim assumes that a static image should be output
+which it then renders using the same strategy by calling the render loop
+(see below) once.
+
+**Back in our toy example,** the call to [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) first
+triggers [`Scene.setup()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.setup) (which only consists of `pass`), followed by
+a call of [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct). At this point, our *animation script*
+is run, starting with the initialization of `orange_square`.
+
+## Mobject Initialization
+
+Mobjects are, in a nutshell, the Python objects that represent all the
+*things* we want to display in our scene. Before we follow our debugger
+into the depths of mobject initialization code, it makes sense to
+discuss Manim’s different types of Mobjects and their basic data
+structure.
+
+### What even is a Mobject?
+
+[`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) stands for *mathematical object* or *Manim object*
+(depends on who you ask 😄). The Python class [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is
+the base class for all objects that should be displayed on screen.
+Looking at the [initialization method](https://github.com/ManimCommunity/manim/blob/5d72d9cfa2e3dd21c844b1da807576f5a7194fda/manim/mobject/mobject.py#L94)
+of [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), you will find that not too much happens in there:
+
+- some initial attribute values are assigned, like `name` (which makes the
+  render logs mention the name of the mobject instead of its type),
+  `submobjects` (initially an empty list), `color`, and some others.
+- Then, two methods related to *points* are called: `reset_points`
+  followed by `generate_points`,
+- and finally, `init_colors` is called.
+
+Digging deeper, you will find that [`Mobject.reset_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.reset_points) simply
+sets the `points` attribute of the mobject to an empty NumPy vector,
+while the other two methods, [`Mobject.generate_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.generate_points) and
+[`Mobject.init_colors()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.init_colors) are just implemented as `pass`.
+
+This makes sense: [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is not supposed to be used as
+an *actual* object that is displayed on screen; in fact the camera
+(which we will discuss later in more detail; it is the class that is,
+for the Cairo renderer, responsible for “taking a picture” of the
+current scene) does not process “pure” [`Mobjects`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+in any way, they *cannot* even appear in the rendered output.
+
+This is where different types of mobjects come into play. Roughly
+speaking, the Cairo renderer setup knows three different types of
+mobjects that can be rendered:
+
+- [`ImageMobject`](../reference/manim.mobject.types.image_mobject.ImageMobject.md#manim.mobject.types.image_mobject.ImageMobject), which represent images that you can display
+  in your scene,
+- [`PMobject`](../reference/manim.mobject.types.point_cloud_mobject.PMobject.md#manim.mobject.types.point_cloud_mobject.PMobject), which are very special mobjects used to represent
+  point clouds; we will not discuss them further in this guide,
+- [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), which are *vectorized mobjects*, that is, mobjects
+  that consist of points that are connected via curves. These are pretty
+  much everywhere, and we will discuss them in detail in the next section.
+
+### … and what are VMobjects?
+
+As just mentioned, [`VMobjects`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) represent vectorized
+mobjects. To render a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), the camera looks at the
+`points` attribute of a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) and divides it into sets
+of four points each. Each of these sets is then used to construct a
+cubic Bézier curve with the first and last entry describing the
+end points of the curve (“anchors”), and the second and third entry
+describing the control points in between (“handles”).
+
+In contrast to [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) can be displayed
+on screen (even though, technically, it is still considered a base class).
+To illustrate how points are processed, consider the following short example
+of a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) with 8 points (and thus made out of 8/4 = 2 cubic
+Bézier curves). The resulting [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) is drawn in green.
+The handles are drawn as red dots with a line to their closest anchor.
+
+<div id="vmobjectdemo" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: VMobjectDemo <a class="headerlink" href="#vmobjectdemo">¶</a></p>![image](media/images/VMobjectDemo-1.png)
+```python
+from manim import *
+
+class VMobjectDemo(Scene):
+    def construct(self):
+        plane = NumberPlane()
+        my_vmobject = VMobject(color=GREEN)
+        my_vmobject.points = [
+            np.array([-2, -1, 0]),  # start of first curve
+            np.array([-3, 1, 0]),
+            np.array([0, 3, 0]),
+            np.array([1, 3, 0]),  # end of first curve
+            np.array([1, 3, 0]),  # start of second curve
+            np.array([0, 1, 0]),
+            np.array([4, 3, 0]),
+            np.array([4, -2, 0]),  # end of second curve
+        ]
+        handles = [
+            Dot(point, color=RED) for point in
+            [[-3, 1, 0], [0, 3, 0], [0, 1, 0], [4, 3, 0]]
+        ]
+        handle_lines = [
+            Line(
+                my_vmobject.points[ind],
+                my_vmobject.points[ind+1],
+                color=RED,
+                stroke_width=2
+            ) for ind in range(0, len(my_vmobject.points), 2)
+        ]
+        self.add(plane, *handles, *handle_lines, my_vmobject)
+```
+
+<pre data-manim-binder data-manim-classname="VMobjectDemo">
+class VMobjectDemo(Scene):
+    def construct(self):
+        plane = NumberPlane()
+        my_vmobject = VMobject(color=GREEN)
+        my_vmobject.points = [
+            np.array([-2, -1, 0]),  # start of first curve
+            np.array([-3, 1, 0]),
+            np.array([0, 3, 0]),
+            np.array([1, 3, 0]),  # end of first curve
+            np.array([1, 3, 0]),  # start of second curve
+            np.array([0, 1, 0]),
+            np.array([4, 3, 0]),
+            np.array([4, -2, 0]),  # end of second curve
+        ]
+        handles = [
+            Dot(point, color=RED) for point in
+            [[-3, 1, 0], [0, 3, 0], [0, 1, 0], [4, 3, 0]]
+        ]
+        handle_lines = [
+            Line(
+                my_vmobject.points[ind],
+                my_vmobject.points[ind+1],
+                color=RED,
+                stroke_width=2
+            ) for ind in range(0, len(my_vmobject.points), 2)
+        ]
+        self.add(plane, \*handles, \*handle_lines, my_vmobject)
+
+</pre></div>
+
+#### WARNING
+Manually setting the points of your [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) is usually
+discouraged; there are specialized methods that can take care of
+that for you – but it might be relevant when implementing your own,
+custom [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Squares and Circles: back to our Toy Example
+
+With a basic understanding of different types of mobjects,
+and an idea of how vectorized mobjects are built we can now
+come back to our toy example and the execution of the
+[`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) method. In the first two lines
+of our animation script, the `orange_square` and the
+`blue_circle` are initialized.
+
+When creating the orange square by running
+
+```default
+Square(color=ORANGE, fill_opacity=0.5)
+```
+
+the initialization method of [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square),
+`Square.__init__`, is called. [Looking at the
+implementation](https://github.com/ManimCommunity/manim/blob/5d72d9cfa2e3dd21c844b1da807576f5a7194fda/manim/mobject/geometry/polygram.py#L607),
+we can see that the `side_length` attribute of the square is set,
+and then
+
+```default
+super().__init__(height=side_length, width=side_length, **kwargs)
+```
+
+is called. This `super` call is the Python way of calling the
+initialization function of the parent class. As [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square)
+inherits from [`Rectangle`](../reference/manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle), the next method called
+is `Rectangle.__init__`. There, only the first three lines
+are really relevant for us:
+
+```default
+super().__init__(UR, UL, DL, DR, color=color, **kwargs)
+self.stretch_to_fit_width(width)
+self.stretch_to_fit_height(height)
+```
+
+First, the initialization function of the parent class of
+[`Rectangle`](../reference/manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle) – [`Polygon`](../reference/manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) – is called. The
+four positional arguments passed are the four corners of
+the polygon: `UR` is up right (and equal to `UP + RIGHT`),
+`UL` is up left (and equal to `UP + LEFT`), and so forth.
+Before we follow our debugger deeper, let us observe what
+happens with the constructed polygon: the remaining two lines
+stretch the polygon to fit the specified width and height
+such that a rectangle with the desired measurements is created.
+
+The initialization function of [`Polygon`](../reference/manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) is particularly
+simple, it only calls the initialization function of its parent
+class, [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram). There, we have almost reached the end
+of the chain: [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) inherits from [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject),
+whose initialization function mainly sets the values of some
+attributes (quite similar to `Mobject.__init__`, but more specific
+to the Bézier curves that make up the mobject).
+
+After calling the initialization function of [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject),
+the constructor of [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) also does something somewhat
+odd: it sets the points (which, you might remember above, should
+actually be set in a corresponding `generate_points` method
+of [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram)).
+
+#### WARNING
+In several instances, the implementation of mobjects does
+not really stick to all aspects of Manim’s interface. This
+is unfortunate, and increasing consistency is something
+that we actively work on. Help is welcome!
+
+Without going too much into detail, [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) sets its
+`points` attribute via [`VMobject.start_new_path()`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.start_new_path),
+[`VMobject.add_points_as_corners()`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.add_points_as_corners), which take care of
+setting the quadruples of anchors and handles appropriately.
+After the points are set, Python continues to process the
+call stack until it reaches the method that was first called;
+the initialization method of [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square). After this,
+the square is initialized and assigned to the `orange_square`
+variable.
+
+The initialization of `blue_circle` is similar to the one of
+`orange_square`, with the main difference being that the inheritance
+chain of [`Circle`](../reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) is different. Let us briefly follow the trace
+of the debugger:
+
+The implementation of `Circle.__init__()` immediately calls
+the initialization method of [`Arc`](../reference/manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc), as a circle in Manim
+is simply an arc with an angle of $\tau = 2\pi$. When
+initializing the arc, some basic attributes are set (like
+`Arc.radius`, `Arc.arc_center`, `Arc.start_angle`, and
+`Arc.angle`), and then the initialization method of its
+parent class, [`TipableVMobject`](../reference/manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject), is called (which is
+a rather abstract base class for mobjects which a arrow tip can
+be attached to). Note that in contrast to [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram),
+this class does **not** preemptively generate the points of the circle.
+
+After that, things are less exciting: [`TipableVMobject`](../reference/manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject) again
+sets some attributes relevant for adding arrow tips, and afterwards
+passes to the initialization method of [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). From there,
+[`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is initialized and [`Mobject.generate_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.generate_points)
+is called, which actually runs the method implemented in
+[`Arc.generate_points()`](../reference/manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc.generate_points).
+
+After both our `orange_square` and the `blue_circle` are initialized,
+the square is actually added to the scene. The [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) method
+is actually doing a few interesting things, so it is worth to dig a bit
+deeper in the next section.
+
+### Adding Mobjects to the Scene
+
+The code in our `construct` method that is run next is
+
+```default
+self.add(orange_square)
+```
+
+From a high-level point of view, [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) adds the
+`orange_square` to the list of mobjects that should be rendered,
+which is stored in the `mobjects` attribute of the scene. However,
+it does so in a very careful way to avoid the situation that a mobject
+is being added to the scene more than once. At a first glance, this
+sounds like a simple task – the problem is that `Scene.mobjects`
+is not a “flat” list of mobjects, but a list of mobjects which
+might contain mobjects themselves, and so on.
+
+Stepping through the code in [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add), we see that first
+it is checked whether we are currently using the OpenGL renderer
+(which we are not) – adding mobjects to the scene works slightly
+different (and actually easier!) for the OpenGL renderer. Then, the
+code branch for the Cairo renderer is entered and the list of so-called
+foreground mobjects (which are rendered on top of all other mobjects)
+is added to the list of passed mobjects. This is to ensure that the
+foreground mobjects will stay above of the other mobjects, even after
+adding the new ones. In our case, the list of foreground mobjects
+is actually empty, and nothing changes.
+
+Next, [`Scene.restructure_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.restructure_mobjects) is called with the list
+of mobjects to be added as the `to_remove` argument, which might
+sound odd at first. Practically, this ensures that mobjects are not
+added twice, as mentioned above: if they were present in the scene
+`Scene.mobjects` list before (even if they were contained as a
+child of some other mobject), they are first removed from the list.
+The way [`Scene.restructure_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.restructure_mobjects) works is rather aggressive:
+It always operates on a given list of mobjects; in the `add` method
+two different lists occur: the default one, `Scene.mobjects` (no extra
+keyword argument is passed), and `Scene.moving_mobjects` (which we will
+discuss later in more detail). It iterates through all of the members of
+the list, and checks whether any of the mobjects passed in `to_remove`
+are contained as children (in any nesting level). If so, **their parent
+mobject is deconstructed** and their siblings are inserted directly
+one level higher. Consider the following example:
+
+```default
+>>> from manim import Scene, Square, Circle, Group
+>>> test_scene = Scene()
+>>> mob1 = Square()
+>>> mob2 = Circle()
+>>> mob_group = Group(mob1, mob2)
+>>> test_scene.add(mob_group)
+<manim.scene.scene.Scene object at ...>
+>>> test_scene.mobjects
+[Group]
+>>> test_scene.restructure_mobjects(to_remove=[mob1])
+<manim.scene.scene.Scene object at ...>
+>>> test_scene.mobjects
+[Circle]
+```
+
+Note that the group is disbanded and the circle moves into the
+root layer of mobjects in `test_scene.mobjects`.
+
+After the mobject list is “restructured”, the mobject to be added
+are simply appended to `Scene.mobjects`. In our toy example,
+the `Scene.mobjects` list is actually empty, so the
+`restructure_mobjects` method does not actually do anything. The
+`orange_square` is simply added to `Scene.mobjects`, and as
+the aforementioned `Scene.moving_mobjects` list is, at this point,
+also still empty, nothing happens and [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) returns.
+
+We will hear more about the `moving_mobject` list when we discuss
+the render loop. Before we do that, let us look at the next line
+of code in our toy example, which includes the initialization of
+an animation class,
+
+```default
+ReplacementTransform(orange_square, blue_circle, run_time=3)
+```
+
+Hence it is time to talk about [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+
+## Animations and the Render Loop
+
+### Initializing animations
+
+Before we follow the trace of the debugger, let us briefly discuss
+the general structure of the (abstract) base class [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+An animation object holds all the information necessary for the renderer
+to generate the corresponding frames. Animations (in the sense of
+animation objects) in Manim are *always* tied to a specific mobject;
+even in the case of [`AnimationGroup`](../reference/manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup) (which you should actually
+think of as an animation on a group of mobjects rather than a group
+of animations). Moreover, except for in a particular special case,
+the run time of animations is also fixed and known beforehand.
+
+The initialization of animations actually is not very exciting,
+`Animation.__init__()` merely sets some attributes derived
+from the passed keyword arguments and additionally ensures that
+the `Animation.starting_mobject` and `Animation.mobject`
+attributes are populated. Once the animation is played, the
+`starting_mobject` attribute holds an unmodified copy of the
+mobject the animation is attached to; during the initialization
+it is set to a placeholder mobject. The `mobject` attribute
+is set to the mobject the animation is attached to.
+
+Animations have a few special methods which are called during the
+render loop:
+
+- [`Animation.begin()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.begin), which is called (as hinted by its name)
+  at the beginning of every animation, so before the first frame
+  is rendered. In it, all the required setup for the animation happens.
+- [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish) is the counterpart to the `begin` method
+  which is called at the end of the life cycle of the animation (after
+  the last frame has been rendered).
+- [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate) is the method that updates the mobject
+  attached to the animation to the corresponding animation completion
+  percentage. For example, if in the render loop,
+  `some_animation.interpolate(0.5)` is called, the attached mobject
+  will be updated to the state where 50% of the animation are completed.
+
+We will discuss details about these and some further animation methods
+once we walk through the actual render loop. For now, we continue with
+our toy example and the code that is run when initializing the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) animation.
+
+The initialization method of [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) only
+consists of a call to the constructor of its parent class,
+[`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform), with the additional keyword argument
+`replace_mobject_with_target_in_scene` set to `True`.
+[`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform) then sets attributes that control how the
+points of the starting mobject are deformed into the points of
+the target mobject, and then passes on to the initialization
+method of [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation). Other basic properties of the
+animation (like its `run_time`, the `rate_func`, etc.) are
+processed there – and then the animation object is fully
+initialized and ready to be played.
+
+### The `play` call: preparing to enter Manim’s render loop
+
+We are finally there, the render loop is in our reach. Let us
+walk through the code that is run when [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) is called.
+
+As you will see when inspecting the method, [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) almost
+immediately passes over to the `play` method of the renderer,
+in our case `CairoRenderer.play`. The one thing [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play)
+takes care of is the management of subcaptions that you might have
+passed to it (see the the documentation of [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) and
+[`Scene.add_subcaption()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add_subcaption) for more information).
+
+#### WARNING
+As has been said before, the communication between scene and renderer
+is not in a very clean state at this point, so the following paragraphs
+might be confusing if you don’t run a debugger and step through the
+code yourself a bit.
+
+Inside `CairoRenderer.play()`, the renderer first checks whether
+it may skip rendering of the current play call. This might happen, for example,
+when `-s` is passed to the CLI (i.e., only the last frame should be rendered),
+or when the `-n` flag is passed and the current play call is outside of the
+specified render bounds. The “skipping status” is updated in form of the
+call to `CairoRenderer.update_skipping_status()`.
+
+Next, the renderer asks the scene to process the animations in the play
+call so that renderer obtains all of the information it needs. To
+be more concrete, [`Scene.compile_animation_data()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.compile_animation_data) is called,
+which then takes care of several things:
+
+- The method processes all animations and the keyword arguments passed
+  to the initial [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call. In particular, this means
+  that it makes sure all arguments passed to the play call are actually
+  animations (or `.animate` syntax calls, which are also assembled to
+  be actual [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation)-objects at that point). It also propagates
+  any animation-related keyword arguments (like `run_time`,
+  or `rate_func`) passed to `Scene.play` to each individual
+  animation. The processed animations are then stored in the `animations`
+  attribute of the scene (which the renderer later reads…).
+- It adds all mobjects to which the animations that are played are
+  bound to to the scene (provided the animation is not an mobject-introducing
+  animation – for these, the addition to the scene happens later).
+- In case the played animation is a [`Wait`](../reference/manim.animation.animation.Wait.md#manim.animation.animation.Wait) animation (this is the
+  case in a [`Scene.wait()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.wait) call), the method checks whether a static
+  image should be rendered, or whether the render loop should be processed
+  as usual (see [`Scene.should_update_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.should_update_mobjects) for the exact conditions,
+  basically it checks whether there are any time-dependent updater functions
+  and so on).
+- Finally, the method determines the total run time of the play call (which
+  at this point is computed as the maximum of the run times of the passed
+  animations). This is stored in the `duration` attribute of the scene.
+
+After the animation data has been compiled by the scene, the renderer
+continues to prepare for entering the render loop. It now checks the
+skipping status which has been determined before. If the renderer can
+skip this play call, it does so: it sets the current play call hash (which
+we will get back to in a moment) to `None` and increases the time of the
+renderer by the determined animation run time.
+
+Otherwise, the renderer checks whether or not Manim’s caching system should
+be used. The idea of the caching system is simple: for every play call, a
+hash value is computed, which is then stored and upon re-rendering the scene,
+the hash is generated again and checked against the stored value. If it is the
+same, the cached output is reused, otherwise it is fully rerendered again.
+We will not go into details of the caching system here; if you would like
+to learn more, the [`get_hash_from_play_call()`](../reference/manim.utils.hashing.md#manim.utils.hashing.get_hash_from_play_call) function in the
+[`utils.hashing`](../reference/manim.utils.hashing.md#module-manim.utils.hashing) module is essentially the entry point to the caching
+mechanism.
+
+In the event that the animation has to be rendered, the renderer asks
+its [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to open an output container. The process
+is started by a call to `libav` and opens a container to which rendered
+raw frames can be written. As long as the output is open, the container
+can be accessed via the `output_container` attribute of the file writer.
+With the writing process in place, the renderer then asks the scene
+to “begin” the animations.
+
+First, it literally *begins* all of the animations by calling their
+setup methods ([`Animation._setup_scene()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation._setup_scene), [`Animation.begin()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.begin)).
+In doing so, the mobjects that are newly introduced by an animation
+(like via [`Create`](../reference/manim.animation.creation.Create.md#manim.animation.creation.Create) etc.) are added to the scene. Furthermore, the
+animation suspends updater functions being called on its mobject, and
+it sets its mobject to the state that corresponds to the first frame
+of the animation.
+
+After this has happened for all animations in the current `play` call,
+the Cairo renderer determines which of the scene’s mobjects can be
+painted statically to the background, and which ones have to be
+redrawn every frame. It does so by calling
+`Scene.get_moving_and_static_mobjects()`, and the resulting
+partition of mobjects is stored in the corresponding `moving_mobjects`
+and `static_mobjects` attributes.
+
+#### NOTE
+The mechanism that determines static and moving mobjects is
+specific for the Cairo renderer, the OpenGL renderer works differently.
+Basically, moving mobjects are determined by checking whether they,
+any of their children, or any of the mobjects “below” them (in the
+sense of the order in which mobjects are processed in the scene)
+either have an update function attached, or whether they appear
+in one of the current animations. See the implementation of
+[`Scene.get_moving_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_moving_mobjects) for more details.
+
+Up to this very point, we did not actually render any (partial)
+image or movie files from the scene yet. This is, however, about to change.
+Before we enter the render loop, let us briefly revisit our toy
+example and discuss how the generic [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call
+setup looks like there.
+
+For the call that plays the [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform), there
+is no subcaption to be taken care of. The renderer then asks
+the scene to compile the animation data: the passed argument
+already is an animation (no additional preparations needed),
+there is no need for processing any keyword arguments (as
+we did not specify any additional ones to `play`). The
+mobject bound to the animation, `orange_square`, is already
+part of the scene (so again, no action taken). Finally, the run
+time is extracted (3 seconds long) and stored in
+`Scene.duration`. The renderer then checks whether it should
+skip (it should not), then whether the animation is already
+cached (it is not). The corresponding animation hash value is
+determined and passed to the file writer, which then also calls
+`libav` to start the writing process which waits for rendered
+frames from the library.
+
+The scene then `begin`s the animation: for the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) this means that the animation populates
+all of its relevant animation attributes (i.e., compatible copies
+of the starting and the target mobject so that it can safely interpolate
+between the two).
+
+The mechanism determining static and moving mobjects considers
+all of the scenes mobjects (at this point only the
+`orange_square`), and determines that the `orange_square` is
+bound to an animation that is currently played. As a result,
+the square is classified as a “moving mobject”.
+
+Time to render some frames.
+
+### The render loop (for real this time)
+
+As mentioned above, due to the mechanism that determines static and moving
+mobjects in the scene, the renderer knows which mobjects it can paint
+statically to the background of the scene. Practically, this means that
+it partially renders a scene (to produce a background image), and then
+when iterating through the time progression of the animation only the
+“moving mobjects” are re-painted on top of the static background.
+
+The renderer calls `CairoRenderer.save_static_frame_data()`, which
+first checks whether there are currently any static mobjects, and if there
+are, it updates the frame (only with the static mobjects; more about how
+exactly this works in a moment) and then saves a NumPy array representing
+the rendered frame in the `static_image` attribute. In our toy example,
+there are no static mobjects, and so the `static_image` attribute is
+simply set to `None`.
+
+Next, the renderer asks the scene whether the current animation is
+a “frozen frame” animation, which would mean that the renderer actually
+does not have to repaint the moving mobjects in every frame of the time
+progression. It can then just take the latest static frame, and display it
+throughout the animation.
+
+#### NOTE
+An animation is considered a “frozen frame” animation if only a
+static [`Wait`](../reference/manim.animation.animation.Wait.md#manim.animation.animation.Wait) animation is played. See the description
+of [`Scene.compile_animation_data()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.compile_animation_data) above, or the
+implementation of [`Scene.should_update_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.should_update_mobjects) for
+more details.
+
+If this is not the case (just as in our toy example), the renderer
+then calls the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) method, which is the
+integral part of the render loop (in which the library steps through
+the time progression of the animation and renders the corresponding
+frames).
+
+Within [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal), the following steps are performed:
+
+- The scene determines the run time of the animations by calling
+  [`Scene.get_run_time()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_run_time). This method basically takes the maximum
+  `run_time` attribute of all of the animations passed to the
+  [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call.
+- Then the *time progression* is constructed via the (internal)
+  [`Scene._get_animation_time_progression()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene._get_animation_time_progression) method, which wraps
+  the actual [`Scene.get_time_progression()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_time_progression) method. The time
+  progression is a `tqdm` [progress bar object](https://tqdm.github.io)
+  for an iterator over `np.arange(0, run_time, 1 / config.frame_rate)`. In
+  other words, the time progression holds the time stamps (relative to the
+  current animations, so starting at 0 and ending at the total animation run time,
+  with the step size determined by the render frame rate) of the timeline where
+  a new animation frame should be rendered.
+- Then the scene iterates over the time progression: for each time stamp `t`,
+  `Scene.update_to_time()` is called, which …
+  - … first computes the time passed since the last update (which might be 0,
+    especially for the initial call) and references it as `dt`,
+  - then (in the order in which the animations are passed to [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play))
+    calls [`Animation.update_mobjects()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.update_mobjects) to trigger all updater functions that
+    are attached to the respective animation except for the “main mobject” of
+    the animation (that is, for example, for [`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform) the unmodified
+    copies of start and target mobject – see [`Animation.get_all_mobjects_to_update()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.get_all_mobjects_to_update)
+    for more details),
+  - then the relative time progression with respect to the current animation
+    is computed (`alpha = t / animation.run_time`), which is then used to
+    update the state of the animation with a call to [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate).
+  - After all of the passed animations have been processed, the updater functions
+    of all mobjects in the scene, all meshes, and finally those attached to
+    the scene itself are run.
+
+At this point, the internal (Python) state of all mobjects has been updated
+to match the currently processed timestamp. If rendering should not be skipped,
+then it is now time to *take a picture*!
+
+#### NOTE
+The update of the internal state (iteration over the time progression) happens
+*always* once [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) is entered. This ensures that even
+if frames do not need to be rendered (because, e.g., the `-n` CLI flag has
+been passed, something has been cached, or because we might be in a *Section*
+with skipped rendering), updater functions still run correctly, and the state
+of the first frame that *is* rendered is kept consistent.
+
+To render an image, the scene calls the corresponding method of its renderer,
+`CairoRenderer.render()` and passes just the list of *moving mobjects* (remember,
+the *static mobjects* are assumed to have already been painted statically to
+the background of the scene). All of the hard work then happens when the renderer
+updates its current frame via a call to `CairoRenderer.update_frame()`:
+
+First, the renderer prepares its [`Camera`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera) by checking whether the renderer
+has a `static_image` different from `None` stored already. If so, it sets the
+image as the *background image* of the camera via `Camera.set_frame_to_background()`,
+and otherwise it just resets the camera via [`Camera.reset()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.reset). The camera is then
+asked to capture the scene with a call to [`Camera.capture_mobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.capture_mobjects).
+
+Things get a bit technical here, and at some point it is more efficient to
+delve into the implementation – but here is a summary of what happens once the
+camera is asked to capture the scene:
+
+- First, a flat list of mobjects is created (so submobjects get extracted from
+  their parents). This list is then processed in groups of the same type of
+  mobjects (e.g., a batch of vectorized mobjects, followed by a batch of image mobjects,
+  followed by more vectorized mobjects, etc. – in many cases there will just be
+  one batch of vectorized mobjects).
+- Depending on the type of the currently processed batch, the camera uses dedicated
+  *display functions* to convert the [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) Python object to
+  a NumPy array stored in the camera’s `pixel_array` attribute.
+  The most important example in that context is the display function for
+  vectorized mobjects, [`Camera.display_multiple_vectorized_mobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_multiple_vectorized_mobjects),
+  or the more particular (in case you did not add a background image to your
+  [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)), [`Camera.display_multiple_non_background_colored_vmobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_multiple_non_background_colored_vmobjects).
+  This method first gets the current Cairo context, and then, for every (vectorized)
+  mobject in the batch, calls [`Camera.display_vectorized()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_vectorized). There,
+  the actual background stroke, fill, and then stroke of the mobject is
+  drawn onto the context. See [`Camera.apply_stroke()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.apply_stroke) and
+  [`Camera.set_cairo_context_color()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.set_cairo_context_color) for more details – but it does not get
+  much deeper than that, in the latter method the actual Bézier curves
+  determined by the points of the mobject are drawn; this is where the low-level
+  interaction with Cairo happens.
+
+After all batches have been processed, the camera has an image representation
+of the Scene at the current time stamp in form of a NumPy array stored in its
+`pixel_array` attribute. The renderer then takes this array and passes it to
+its [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter). This concludes one iteration of the render loop,
+and once the time progression has been processed completely, a final bit
+of cleanup is performed before the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call is completed.
+
+A TL;DR for the render loop, in the context of our toy example, reads as follows:
+
+- The scene finds that a 3 second long animation (the [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform)
+  changing the orange square to the blue circle) should be played. Given the requested
+  medium render quality, the frame rate is 30 frames per second, and so the time
+  progression with steps `[0, 1/30, 2/30, ..., 89/30]` is created.
+- In the internal render loop, each of these time stamps is processed:
+  there are no updater functions, so effectively the scene updates the
+  state of the transformation animation to the desired time stamp (for example,
+  at time stamp `t = 45/30`, the animation is completed to a rate of
+  `alpha = 0.5`).
+- Then the scene asks the renderer to do its job. The renderer asks its camera
+  to capture the scene, the only mobject that needs to be processed at this point
+  is the main mobject attached to the transformation; the camera converts the
+  current state of the mobject to entries in a NumPy array. The renderer passes
+  this array to the file writer.
+- At the end of the loop, 90 frames have been passed to the file writer.
+
+### Completing the render loop
+
+The last few steps in the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call are not too
+exciting: for every animation, the corresponding [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish)
+and [`Animation.clean_up_from_scene()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.clean_up_from_scene) methods are called.
+
+#### NOTE
+Note that as part of [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish), the [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate)
+method is called with an argument of 1.0 – you might have noticed already that
+the last frame of an animation can sometimes be a bit off or incomplete.
+This is by current design! The last frame rendered in the render loop (and displayed
+for a duration of `1 / frame_rate` seconds in the rendered video) corresponds to
+the state of the animation `1 / frame_rate` seconds before it ends. To display
+the final frame as well in the video, we would need to append another `1 / frame_rate`
+seconds to the video – which would then mean that a 1 second rendered Manim video
+would be slightly longer than 1 second. We decided against this at some point.
+
+In the end, the time progression is closed (which completes the displayed progress bar)
+in the terminal. With the closing of the time progression, the
+[`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call is completed, and we return to the renderer,
+which now orders the [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to close the output container that has
+been opened for this animation: a partial movie file is written.
+
+This pretty much concludes the walkthrough of a `Scene.play` call,
+and actually there is not too much more to say for our toy example either: at
+this point, a partial movie file that represents playing the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) has been written. The initialization of
+the [`Dot`](../reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) happens analogous to the initialization of `blue_circle`,
+which has been discussed above. The [`Mobject.add_updater()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) call literally
+just attaches a function to the `updaters` attribute of the `small_dot`. And
+the remaining [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) and [`Scene.wait()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.wait) calls follow the
+exact same procedure as discussed in the render loop section above; each such call
+produces a corresponding partial movie file.
+
+Once the [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) method has been fully processed (and thus all
+of the corresponding partial movie files have been written), the
+scene calls its cleanup method [`Scene.tear_down()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.tear_down), and then
+asks its renderer to finish the scene. The renderer, in turn, asks
+its scene file writer to wrap things up by calling [`SceneFileWriter.finish()`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter.finish),
+which triggers the combination of the partial movie files into the final product.
+
+And there you go! This is a more or less detailed description of how Manim works
+under the hood. While we did not discuss every single line of code in detail
+in this walkthrough, it should still give you a fairly good idea of how the general
+structural design of the library and at least the Cairo rendering flow in particular
+looks like.

data/rag/manim_docs/manim_core/docs/guides/using_text.md

@@ -0,0 +1,826 @@
+# Rendering Text and Formulas
+
+There are two different ways by which you can render **Text** in videos:
+
+1. Using Pango ([`text_mobject`](../reference/manim.mobject.text.text_mobject.md#module-manim.mobject.text.text_mobject))
+2. Using LaTeX ([`tex_mobject`](../reference/manim.mobject.text.tex_mobject.md#module-manim.mobject.text.tex_mobject))
+
+If you want to render simple text, you should use either [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or
+[`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText), or one of its derivatives like [`Paragraph`](../reference/manim.mobject.text.text_mobject.Paragraph.md#manim.mobject.text.text_mobject.Paragraph).
+See [Text Without LaTeX](#using-text-objects) for more information.
+
+LaTeX should be used when you need mathematical typesetting. See
+[Text With LaTeX](#rendering-with-latex) for more information.
+
+<a id="using-text-objects"></a>
+
+## Text Without LaTeX
+
+The simplest way to add text to your animations is to use the [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+class. It uses the [Pango library](https://pango.gnome.org) to render text. With Pango, you can also
+render non-English alphabets like 你好 or  こんにちは or 안녕하세요 or
+مرحبا بالعالم.
+
+Here is a simple *Hello World* animation.
+
+<div id="helloworld" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: HelloWorld <a class="headerlink" href="#helloworld">¶</a></p>![image](media/images/HelloWorld-1.png)
+```python
+from manim import *
+
+class HelloWorld(Scene):
+    def construct(self):
+        text = Text("Hello world", font_size=144)
+        self.add(text)
+```
+
+<pre data-manim-binder data-manim-classname="HelloWorld">
+class HelloWorld(Scene):
+    def construct(self):
+        text = Text("Hello world", font_size=144)
+        self.add(text)
+
+</pre>
+
+References: [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+</div>
+
+You can also use [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) which allows the use of PangoMarkup
+(see the documentation of [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) for details) to render text.
+For example:
+
+<div id="singlelinecolor" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SingleLineColor <a class="headerlink" href="#singlelinecolor">¶</a></p>![image](media/images/SingleLineColor-1.png)
+```python
+from manim import *
+
+class SingleLineColor(Scene):
+    def construct(self):
+        text = MarkupText(
+            f'all in red <span fgcolor="{YELLOW}">except this</span>', color=RED
+        )
+        self.add(text)
+```
+
+<pre data-manim-binder data-manim-classname="SingleLineColor">
+class SingleLineColor(Scene):
+    def construct(self):
+        text = MarkupText(
+            f'all in red <span fgcolor="{YELLOW}">except this</span>', color=RED
+        )
+        self.add(text)
+
+</pre>
+
+References: [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText)
+
+</div>
+
+### Working with [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+This section explains the properties of [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) and how can it be used
+in your animations.
+
+#### Using Fonts
+
+You can set a different font using `font`.
+
+#### NOTE
+The font used must be installed in your system, and Pango should know
+about it. You can get a list of fonts using `manimpango.list_fonts()`.
+
+```pycon
+>>> import manimpango
+>>> manimpango.list_fonts()
+[...]
+```
+
+<div id="fontsexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: FontsExample <a class="headerlink" href="#fontsexample">¶</a></p>![image](media/images/FontsExample-1.png)
+```python
+from manim import *
+
+class FontsExample(Scene):
+    def construct(self):
+        ft = Text("Noto Sans", font="Noto Sans")
+        self.add(ft)
+```
+
+<pre data-manim-binder data-manim-classname="FontsExample">
+class FontsExample(Scene):
+    def construct(self):
+        ft = Text("Noto Sans", font="Noto Sans")
+        self.add(ft)
+
+</pre></div>
+
+#### Setting Slant and Weight
+
+Slant is the style of the Text, and it can be `NORMAL` (the default),
+`ITALIC` or `OBLIQUE`. Usually, for many fonts both `ITALIC` and
+`OBLIQUE` look similar, but `ITALIC` uses **Roman Style**, whereas
+`OBLIQUE` uses **Italic Style**.
+
+Weight specifies the boldness of a font. You can see a list of weights in
+`manimpango.Weight`.
+
+<div id="slantsexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SlantsExample <a class="headerlink" href="#slantsexample">¶</a></p>![image](media/images/SlantsExample-1.png)
+```python
+from manim import *
+
+class SlantsExample(Scene):
+    def construct(self):
+        a = Text("Italic", slant=ITALIC)
+        self.add(a)
+```
+
+<pre data-manim-binder data-manim-classname="SlantsExample">
+class SlantsExample(Scene):
+    def construct(self):
+        a = Text("Italic", slant=ITALIC)
+        self.add(a)
+
+</pre></div><div id="differentweight" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: DifferentWeight <a class="headerlink" href="#differentweight">¶</a></p>![image](media/images/DifferentWeight-1.png)
+```python
+from manim import *
+
+class DifferentWeight(Scene):
+    def construct(self):
+        import manimpango
+
+        g = VGroup()
+        weight_list = dict(
+            sorted(
+                {
+                    weight: manimpango.Weight(weight).value
+                    for weight in manimpango.Weight
+                }.items(),
+                key=lambda x: x[1],
+            )
+        )
+        for weight in weight_list:
+            g += Text(weight.name, weight=weight.name, font="Open Sans")
+        self.add(g.arrange(DOWN).scale(0.5))
+```
+
+<pre data-manim-binder data-manim-classname="DifferentWeight">
+class DifferentWeight(Scene):
+    def construct(self):
+        import manimpango
+
+        g = VGroup()
+        weight_list = dict(
+            sorted(
+                {
+                    weight: manimpango.Weight(weight).value
+                    for weight in manimpango.Weight
+                }.items(),
+                key=lambda x: x[1],
+            )
+        )
+        for weight in weight_list:
+            g += Text(weight.name, weight=weight.name, font="Open Sans")
+        self.add(g.arrange(DOWN).scale(0.5))
+
+</pre></div>
+
+<a id="using-colors"></a>
+
+#### Using Colors
+
+You can set the color of the text using `color`:
+
+<div id="simplecolor" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SimpleColor <a class="headerlink" href="#simplecolor">¶</a></p>![image](media/images/SimpleColor-1.png)
+```python
+from manim import *
+
+class SimpleColor(Scene):
+    def construct(self):
+        col = Text("RED COLOR", color=RED)
+        self.add(col)
+```
+
+<pre data-manim-binder data-manim-classname="SimpleColor">
+class SimpleColor(Scene):
+    def construct(self):
+        col = Text("RED COLOR", color=RED)
+        self.add(col)
+
+</pre></div>
+
+You can use utilities like `t2c` for coloring specific characters.
+This may be problematic if your text contains ligatures
+as explained in [Iterating Text](#iterating-text).
+
+`t2c` accepts two types of dictionaries,
+
+* The keys can contain indices like `[2:-1]` or `[4:8]`,
+  this works similar to how [slicing](https://realpython.com/python-strings/#string-slicing)
+  works in Python. The values should be the color of the Text from `Color`.
+* The keys contain words or characters which should be colored separately
+  and the values should be the color from `Color`:
+
+<div id="textt2cexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: Textt2cExample <a class="headerlink" href="#textt2cexample">¶</a></p>![image](media/images/Textt2cExample-1.png)
+```python
+from manim import *
+
+class Textt2cExample(Scene):
+    def construct(self):
+        t2cindices = Text('Hello', t2c={'[1:-1]': BLUE}).move_to(LEFT)
+        t2cwords = Text('World',t2c={'rl':RED}).next_to(t2cindices, RIGHT)
+        self.add(t2cindices, t2cwords)
+```
+
+<pre data-manim-binder data-manim-classname="Textt2cExample">
+class Textt2cExample(Scene):
+    def construct(self):
+        t2cindices = Text('Hello', t2c={'[1:-1]': BLUE}).move_to(LEFT)
+        t2cwords = Text('World',t2c={'rl':RED}).next_to(t2cindices, RIGHT)
+        self.add(t2cindices, t2cwords)
+
+</pre></div>
+
+If you want to avoid problems when using colors (due to ligatures), consider using
+`MarkupText`.
+
+#### Using Gradients
+
+You can add a gradient using `gradient`. The value must
+be an iterable of any length:
+
+<div id="gradientexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GradientExample <a class="headerlink" href="#gradientexample">¶</a></p>![image](media/images/GradientExample-1.png)
+```python
+from manim import *
+
+class GradientExample(Scene):
+    def construct(self):
+        t = Text("Hello", gradient=(RED, BLUE, GREEN), font_size=96)
+        self.add(t)
+```
+
+<pre data-manim-binder data-manim-classname="GradientExample">
+class GradientExample(Scene):
+    def construct(self):
+        t = Text("Hello", gradient=(RED, BLUE, GREEN), font_size=96)
+        self.add(t)
+
+</pre></div>
+
+You can also use `t2g` for gradients with specific
+characters of the text. It shares a similar syntax to [the
+interface for colors](#using-colors):
+
+<div id="t2gexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: t2gExample <a class="headerlink" href="#t2gexample">¶</a></p>![image](media/images/t2gExample-1.png)
+```python
+from manim import *
+
+class t2gExample(Scene):
+    def construct(self):
+        t2gindices = Text(
+            'Hello',
+            t2g={
+                '[1:-1]': (RED,GREEN),
+            },
+        ).move_to(LEFT)
+        t2gwords = Text(
+            'World',
+            t2g={
+                'World':(RED,BLUE),
+            },
+        ).next_to(t2gindices, RIGHT)
+        self.add(t2gindices, t2gwords)
+```
+
+<pre data-manim-binder data-manim-classname="t2gExample">
+class t2gExample(Scene):
+    def construct(self):
+        t2gindices = Text(
+            'Hello',
+            t2g={
+                '[1:-1]': (RED,GREEN),
+            },
+        ).move_to(LEFT)
+        t2gwords = Text(
+            'World',
+            t2g={
+                'World':(RED,BLUE),
+            },
+        ).next_to(t2gindices, RIGHT)
+        self.add(t2gindices, t2gwords)
+
+</pre></div>
+
+#### Setting Line Spacing
+
+You can set the line spacing using `line_spacing`:
+
+<div id="linespacing" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LineSpacing <a class="headerlink" href="#linespacing">¶</a></p>![image](media/images/LineSpacing-1.png)
+```python
+from manim import *
+
+class LineSpacing(Scene):
+    def construct(self):
+        a = Text("Hello\nWorld", line_spacing=1)
+        b = Text("Hello\nWorld", line_spacing=4)
+        self.add(Group(a,b).arrange(LEFT, buff=5))
+```
+
+<pre data-manim-binder data-manim-classname="LineSpacing">
+class LineSpacing(Scene):
+    def construct(self):
+        a = Text("Hello\\nWorld", line_spacing=1)
+        b = Text("Hello\\nWorld", line_spacing=4)
+        self.add(Group(a,b).arrange(LEFT, buff=5))
+
+</pre></div>
+
+<a id="disable-ligatures"></a>
+
+#### Disabling Ligatures
+
+By disabling ligatures you would get a one-to-one mapping between characters and
+submobjects. This fixes the issues with coloring text.
+
+#### WARNING
+Be aware that using this method with text that heavily depends on
+ligatures (Arabic text) may yield unexpected results.
+
+You can disable ligatures by passing `disable_ligatures` to
+`Text`. For example:
+
+<div id="disableligature" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: DisableLigature <a class="headerlink" href="#disableligature">¶</a></p>![image](media/images/DisableLigature-1.png)
+```python
+from manim import *
+
+class DisableLigature(Scene):
+    def construct(self):
+        li = Text("fl ligature",font_size=96)
+        nli = Text("fl ligature", disable_ligatures=True, font_size=96)
+        self.add(Group(li, nli).arrange(DOWN, buff=.8))
+```
+
+<pre data-manim-binder data-manim-classname="DisableLigature">
+class DisableLigature(Scene):
+    def construct(self):
+        li = Text("fl ligature",font_size=96)
+        nli = Text("fl ligature", disable_ligatures=True, font_size=96)
+        self.add(Group(li, nli).arrange(DOWN, buff=.8))
+
+</pre></div>
+
+<a id="iterating-text"></a>
+
+#### Iterating [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+Text objects behave like [`VGroups`](../reference/manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup). Therefore, you can slice and index
+the text.
+
+For example, you can set each letter to different color by iterating it.
+
+<div id="iteratecolor" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: IterateColor <a class="headerlink" href="#iteratecolor">¶</a></p>![image](media/images/IterateColor-1.png)
+```python
+from manim import *
+
+class IterateColor(Scene):
+    def construct(self):
+        text = Text("Colors", font_size=96)
+        for letter in text:
+            letter.set_color(random_bright_color())
+        self.add(text)
+```
+
+<pre data-manim-binder data-manim-classname="IterateColor">
+class IterateColor(Scene):
+    def construct(self):
+        text = Text("Colors", font_size=96)
+        for letter in text:
+            letter.set_color(random_bright_color())
+        self.add(text)
+
+</pre></div>
+
+#### WARNING
+Please note that [Ligature](https://en.wikipedia.org/wiki/Ligature_(writing)) can cause problems here. If you need a
+one-to-one mapping of characters to submobjects you should pass
+the `disable_ligatures` parameter to [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text).
+See [Disabling Ligatures](#disable-ligatures).
+
+### Working with [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText)
+
+MarkupText is similar to [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text), the only difference between them is
+that this accepts and processes PangoMarkup (which is similar to
+html), instead of just rendering plain text.
+
+Consult the documentation of [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) for more details
+and further references about PangoMarkup.
+
+<div id="markuptest" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MarkupTest <a class="headerlink" href="#markuptest">¶</a></p>![image](media/images/MarkupTest-1.png)
+```python
+from manim import *
+
+class MarkupTest(Scene):
+    def construct(self):
+        text = MarkupText(
+            f'<span underline="double" underline_color="green">double green underline</span> in red text<span fgcolor="{YELLOW}"> except this</span>',
+            color=RED,
+            font_size=34
+        )
+        self.add(text)
+```
+
+<pre data-manim-binder data-manim-classname="MarkupTest">
+class MarkupTest(Scene):
+    def construct(self):
+        text = MarkupText(
+            f'<span underline="double" underline_color="green">double green underline</span> in red text<span fgcolor="{YELLOW}"> except this</span>',
+            color=RED,
+            font_size=34
+        )
+        self.add(text)
+
+</pre></div>
+
+<a id="rendering-with-latex"></a>
+
+## Text With LaTeX
+
+Just as you can use [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) to add text to your videos, you can
+use [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) to insert LaTeX.
+
+For example,
+
+<div id="hellolatex" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: HelloLaTeX <a class="headerlink" href="#hellolatex">¶</a></p>![image](media/images/HelloLaTeX-1.png)
+```python
+from manim import *
+
+class HelloLaTeX(Scene):
+    def construct(self):
+        tex = Tex(r"\LaTeX", font_size=144)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="HelloLaTeX">
+class HelloLaTeX(Scene):
+    def construct(self):
+        tex = Tex(r"\\LaTeX", font_size=144)
+        self.add(tex)
+
+</pre></div>
+
+#### NOTE
+Note that we are using a raw string (`r'...'`) instead of a regular string (`'...'`).
+This is because TeX code uses a lot of special characters - like `\` for example - that
+have special meaning within a regular python string. An alternative would have been to
+write `\\` to escape the backslash: `Tex('\\LaTeX')`.
+
+### Working with [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+Everything passed to [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) is in math mode by default. To be more precise,
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) is processed within an `align*` environment. You can achieve a
+similar effect with [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) by enclosing your formula with `$` symbols:
+`$\xrightarrow{x^6y^8}$`:
+
+<div id="mathtexdemo" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: MathTeXDemo <a class="headerlink" href="#mathtexdemo">¶</a></p>![image](media/images/MathTeXDemo-1.png)
+```python
+from manim import *
+
+class MathTeXDemo(Scene):
+    def construct(self):
+        rtarrow0 = MathTex(r"\xrightarrow{x^6y^8}", font_size=96)
+        rtarrow1 = Tex(r"$\xrightarrow{x^6y^8}$", font_size=96)
+
+        self.add(VGroup(rtarrow0, rtarrow1).arrange(DOWN))
+```
+
+<pre data-manim-binder data-manim-classname="MathTeXDemo">
+class MathTeXDemo(Scene):
+    def construct(self):
+        rtarrow0 = MathTex(r"\\xrightarrow{x^6y^8}", font_size=96)
+        rtarrow1 = Tex(r"$\\xrightarrow{x^6y^8}$", font_size=96)
+
+        self.add(VGroup(rtarrow0, rtarrow1).arrange(DOWN))
+
+</pre></div>
+
+### LaTeX commands and keyword arguments
+
+We can use any standard LaTeX commands in the AMS maths packages. Such
+as the `mathtt` math-text type or the `looparrowright` arrow.
+
+<div id="amslatex" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: AMSLaTeX <a class="headerlink" href="#amslatex">¶</a></p>![image](media/images/AMSLaTeX-1.png)
+```python
+from manim import *
+
+class AMSLaTeX(Scene):
+    def construct(self):
+        tex = Tex(r'$\mathtt{H} \looparrowright$ \LaTeX', font_size=144)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="AMSLaTeX">
+class AMSLaTeX(Scene):
+    def construct(self):
+        tex = Tex(r'$\\mathtt{H} \\looparrowright$ \\LaTeX', font_size=144)
+        self.add(tex)
+
+</pre></div>
+
+On the Manim side, the [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) class also accepts attributes to
+change the appearance of the output. This is very similar to the
+[`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) class. For example, the `color` keyword changes the
+color of the TeX mobject.
+
+<div id="latexattributes" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaTeXAttributes <a class="headerlink" href="#latexattributes">¶</a></p>![image](media/images/LaTeXAttributes-1.png)
+```python
+from manim import *
+
+class LaTeXAttributes(Scene):
+    def construct(self):
+        tex = Tex(r'Hello \LaTeX', color=BLUE, font_size=144)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="LaTeXAttributes">
+class LaTeXAttributes(Scene):
+    def construct(self):
+        tex = Tex(r'Hello \\LaTeX', color=BLUE, font_size=144)
+        self.add(tex)
+
+</pre></div>
+
+### Extra LaTeX Packages
+
+Some commands require special packages to be loaded into the TeX template.
+For example, to use the `mathscr` script, we need to add the `mathrsfs`
+package. Since this package isn’t loaded into Manim’s tex template by default,
+we have to add it manually.
+
+<div id="addpackagelatex" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: AddPackageLatex <a class="headerlink" href="#addpackagelatex">¶</a></p>![image](media/images/AddPackageLatex-1.png)
+```python
+from manim import *
+
+class AddPackageLatex(Scene):
+    def construct(self):
+        myTemplate = TexTemplate()
+        myTemplate.add_to_preamble(r"\usepackage{mathrsfs}")
+        tex = Tex(
+            r"$\mathscr{H} \rightarrow \mathbb{H}$",
+            tex_template=myTemplate,
+            font_size=144,
+        )
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="AddPackageLatex">
+class AddPackageLatex(Scene):
+    def construct(self):
+        myTemplate = TexTemplate()
+        myTemplate.add_to_preamble(r"\\usepackage{mathrsfs}")
+        tex = Tex(
+            r"$\\mathscr{H} \\rightarrow \\mathbb{H}$",
+            tex_template=myTemplate,
+            font_size=144,
+        )
+        self.add(tex)
+
+</pre></div>
+
+### Substrings and parts
+
+The TeX mobject can accept multiple strings as arguments. Afterwards you can
+refer to the individual parts either by their index (like `tex[1]`), or by
+selecting parts of the tex code. In this example, we set the color
+of the `\bigstar` using `set_color_by_tex()`:
+
+<div id="latexsubstrings" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaTeXSubstrings <a class="headerlink" href="#latexsubstrings">¶</a></p>![image](media/images/LaTeXSubstrings-1.png)
+```python
+from manim import *
+
+class LaTeXSubstrings(Scene):
+    def construct(self):
+        tex = Tex('Hello', r'$\bigstar$', r'\LaTeX', font_size=144)
+        tex.set_color_by_tex('igsta', RED)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="LaTeXSubstrings">
+class LaTeXSubstrings(Scene):
+    def construct(self):
+        tex = Tex('Hello', r'$\\bigstar$', r'\\LaTeX', font_size=144)
+        tex.set_color_by_tex('igsta', RED)
+        self.add(tex)
+
+</pre></div>
+
+Note that `set_color_by_tex()` colors the entire substring containing
+the Tex, not just the specific symbol or Tex expression. Consider the following example:
+
+<div id="incorrectlatexsubstringcoloring" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: IncorrectLaTeXSubstringColoring <a class="headerlink" href="#incorrectlatexsubstringcoloring">¶</a></p>![image](media/images/IncorrectLaTeXSubstringColoring-1.png)
+```python
+from manim import *
+
+class IncorrectLaTeXSubstringColoring(Scene):
+    def construct(self):
+        equation = MathTex(
+            r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots"
+        )
+        equation.set_color_by_tex("x", YELLOW)
+        self.add(equation)
+```
+
+<pre data-manim-binder data-manim-classname="IncorrectLaTeXSubstringColoring">
+class IncorrectLaTeXSubstringColoring(Scene):
+    def construct(self):
+        equation = MathTex(
+            r"e^x = x^0 + x^1 + \\frac{1}{2} x^2 + \\frac{1}{6} x^3 + \\cdots + \\frac{1}{n!} x^n + \\cdots"
+        )
+        equation.set_color_by_tex("x", YELLOW)
+        self.add(equation)
+
+</pre></div>
+
+As you can see, this colors the entire equation yellow, contrary to what
+may be expected. To color only `x` yellow, we have to do the following:
+
+<div id="correctlatexsubstringcoloring" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: CorrectLaTeXSubstringColoring <a class="headerlink" href="#correctlatexsubstringcoloring">¶</a></p>![image](media/images/CorrectLaTeXSubstringColoring-1.png)
+```python
+from manim import *
+
+class CorrectLaTeXSubstringColoring(Scene):
+    def construct(self):
+        equation = MathTex(
+            r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots",
+            substrings_to_isolate="x"
+        )
+        equation.set_color_by_tex("x", YELLOW)
+        self.add(equation)
+```
+
+<pre data-manim-binder data-manim-classname="CorrectLaTeXSubstringColoring">
+class CorrectLaTeXSubstringColoring(Scene):
+    def construct(self):
+        equation = MathTex(
+            r"e^x = x^0 + x^1 + \\frac{1}{2} x^2 + \\frac{1}{6} x^3 + \\cdots + \\frac{1}{n!} x^n + \\cdots",
+            substrings_to_isolate="x"
+        )
+        equation.set_color_by_tex("x", YELLOW)
+        self.add(equation)
+
+</pre></div>
+
+By setting `substrings_to_isolate` to `x`, we split up the
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) into substrings automatically and isolate the `x` components
+into individual substrings. Only then can `set_color_by_tex()` be used
+to achieve the desired result.
+
+Note that Manim also supports a custom syntax that allows splitting
+a TeX string into substrings easily: simply enclose parts of your formula
+that you want to isolate with double braces. In the string
+`MathTex(r"{{ a^2 }} + {{ b^2 }} = {{ c^2 }}")`, the rendered mobject
+will consist of the substrings `a^2`, `+`, `b^2`, `=`, and `c^2`.
+This makes transformations between similar text fragments easy
+to write using [`TransformMatchingTex`](../reference/manim.animation.transform_matching_parts.TransformMatchingTex.md#manim.animation.transform_matching_parts.TransformMatchingTex).
+
+### Using `index_labels` to work with complicated strings
+
+You might sometimes be working with a very complicated [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) mobject
+that makes it difficult to work with its individual components. This is
+where the debugging function [`index_labels()`](../reference/manim.utils.debug.md#manim.utils.debug.index_labels) is very useful.
+
+The method shows the index of a mobject’s submobjects, allowing you
+to easily find the components of the mobject you would like to change.
+
+<div id="indexlabelsmathtex" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: IndexLabelsMathTex <a class="headerlink" href="#indexlabelsmathtex">¶</a></p>![image](media/images/IndexLabelsMathTex-1.png)
+```python
+from manim import *
+
+class IndexLabelsMathTex(Scene):
+    def construct(self):
+        text = MathTex(r"\binom{2n}{n+2}", font_size=96)
+
+        # index the first (and only) term of the MathTex mob
+        self.add(index_labels(text[0]))
+
+        text[0][1:3].set_color(YELLOW)
+        text[0][3:6].set_color(RED)
+        self.add(text)
+```
+
+<pre data-manim-binder data-manim-classname="IndexLabelsMathTex">
+class IndexLabelsMathTex(Scene):
+    def construct(self):
+        text = MathTex(r"\\binom{2n}{n+2}", font_size=96)
+
+        # index the first (and only) term of the MathTex mob
+        self.add(index_labels(text[0]))
+
+        text[0][1:3].set_color(YELLOW)
+        text[0][3:6].set_color(RED)
+        self.add(text)
+
+</pre></div>
+
+### LaTeX Maths Fonts - The Template Library
+
+Changing fonts in LaTeX when typesetting mathematical formulae is
+trickier than regular text. It requires changing the template that is used
+to compile the TeX. Manim comes with a collection of [`TexFontTemplates`](../reference/manim.utils.tex_templates.TexFontTemplates.md#manim.utils.tex_templates.TexFontTemplates)
+ready for you to use. These templates will all work in math mode:
+
+<div id="latexmathfonts" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaTeXMathFonts <a class="headerlink" href="#latexmathfonts">¶</a></p>![image](media/images/LaTeXMathFonts-1.png)
+```python
+from manim import *
+
+class LaTeXMathFonts(Scene):
+    def construct(self):
+        tex = Tex(
+            r"$x^2 + y^2 = z^2$",
+            tex_template=TexFontTemplates.french_cursive,
+            font_size=144,
+        )
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="LaTeXMathFonts">
+class LaTeXMathFonts(Scene):
+    def construct(self):
+        tex = Tex(
+            r"$x^2 + y^2 = z^2$",
+            tex_template=TexFontTemplates.french_cursive,
+            font_size=144,
+        )
+        self.add(tex)
+
+</pre></div>
+
+Manim also has a [`TexTemplateLibrary`](../reference/manim.utils.tex_templates.TexTemplateLibrary.md#manim.utils.tex_templates.TexTemplateLibrary) containing the TeX
+templates used by 3Blue1Brown. One example is the ctex template,
+used for typesetting Chinese script. For this to work, the ctex LaTeX package
+must be installed on your system. Furthermore, if you are only
+typesetting Text, you probably do not need [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) at all, and
+should use [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) instead.
+
+<div id="latextemplatelibrary" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaTeXTemplateLibrary <a class="headerlink" href="#latextemplatelibrary">¶</a></p>![image](media/images/LaTeXTemplateLibrary-1.png)
+```python
+from manim import *
+
+class LaTeXTemplateLibrary(Scene):
+    def construct(self):
+        tex = Tex('Hello 你好 \\LaTeX', tex_template=TexTemplateLibrary.ctex, font_size=144)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="LaTeXTemplateLibrary">
+class LaTeXTemplateLibrary(Scene):
+    def construct(self):
+        tex = Tex('Hello 你好 \\\\LaTeX', tex_template=TexTemplateLibrary.ctex, font_size=144)
+        self.add(tex)
+
+</pre></div>
+
+### Aligning formulae
+
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) mobject is typeset in the LaTeX  `align*`
+environment. This means you can use the `&` alignment character
+when typesetting multiline formulae:
+
+<div id="latexalignenvironment" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaTeXAlignEnvironment <a class="headerlink" href="#latexalignenvironment">¶</a></p>![image](media/images/LaTeXAlignEnvironment-1.png)
+```python
+from manim import *
+
+class LaTeXAlignEnvironment(Scene):
+    def construct(self):
+        tex = MathTex(r'f(x) &= 3 + 2 + 1\\ &= 5 + 1 \\ &= 6', font_size=96)
+        self.add(tex)
+```
+
+<pre data-manim-binder data-manim-classname="LaTeXAlignEnvironment">
+class LaTeXAlignEnvironment(Scene):
+    def construct(self):
+        tex = MathTex(r'f(x) &= 3 + 2 + 1\\\\ &= 5 + 1 \\\\ &= 6', font_size=96)
+        self.add(tex)
+
+</pre></div>

data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.JSONFormatter.md

@@ -0,0 +1,45 @@
+# JSONFormatter
+
+Qualified name: `manim.\_config.logger\_utils.JSONFormatter`
+
+### *class* JSONFormatter(fmt=None, datefmt=None, style='%', validate=True, \*, defaults=None)
+
+Bases: `Formatter`
+
+A formatter that outputs logs in a custom JSON format.
+
+This class is used internally for testing purposes.
+
+Initialize the formatter with specified format strings.
+
+Initialize the formatter either with the specified format string, or a
+default as described above. Allow for specialized date formatting with
+the optional datefmt argument. If datefmt is omitted, you get an
+ISO8601-like (or RFC 3339-like) format.
+
+Use a style parameter of ‘%’, ‘{’ or ‘$’ to specify that you want to
+use one of %-formatting, `str.format()` (`{}`) formatting or
+`string.Template` formatting in your format string.
+
+#### Versionchanged
+Changed in version 3.2: Added the `style` parameter.
+
+### Methods
+
+| [`format`](#manim._config.logger_utils.JSONFormatter.format)   | Format the record in a custom JSON format.   |
+|----------------------------------------------------------------|----------------------------------------------|
+
+### Attributes
+
+| `default_msec_format`   |    |
+|-------------------------|----|
+| `default_time_format`   |    |
+
+#### format(record)
+
+Format the record in a custom JSON format.
+
+* **Parameters:**
+  **record** (*LogRecord*)
+* **Return type:**
+  str

data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.md

@@ -0,0 +1,67 @@
+# logger_utils
+
+Utilities to create and set the logger.
+
+Manim’s logger can be accessed as `manim.logger`, or as
+`logging.getLogger("manim")`, once the library has been imported.  Manim also
+exports a second object, `console`, which should be used to print on screen
+messages that need not be logged.
+
+Both `logger` and `console` use the `rich` library to produce rich text
+format.
+
+### Classes
+
+| [`JSONFormatter`](manim._config.logger_utils.JSONFormatter.md#manim._config.logger_utils.JSONFormatter)   | A formatter that outputs logs in a custom JSON format.   |
+|-----------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
+
+### Functions
+
+### make_logger(parser, verbosity)
+
+Make the manim logger and console.
+
+* **Parameters:**
+  * **parser** (*SectionProxy*) – A parser containing any .cfg files in use.
+  * **verbosity** (*str*) – The verbosity level of the logger.
+* **Returns:**
+  The manim logger and consoles. The first console outputs
+  to stdout, the second to stderr. All use the theme returned by
+  [`parse_theme()`](#manim._config.logger_utils.parse_theme).
+* **Return type:**
+  `logging.Logger`, `rich.Console`, `rich.Console`
+
+#### SEE ALSO
+[`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser), [`parse_theme()`](#manim._config.logger_utils.parse_theme)
+
+### Notes
+
+The `parser` is assumed to contain only the options related to
+configuring the logger at the top level.
+
+### parse_theme(parser)
+
+Configure the rich style of logger and console output.
+
+* **Parameters:**
+  **parser** (*SectionProxy*) – A parser containing any .cfg files in use.
+* **Returns:**
+  The rich theme to be used by the manim logger.
+* **Return type:**
+  `rich.Theme`
+
+#### SEE ALSO
+[`make_logger()`](#manim._config.logger_utils.make_logger)
+
+### set_file_logger(scene_name, module_name, log_dir)
+
+Add a file handler to manim logger.
+
+The path to the file is built using `config.log_dir`.
+
+* **Parameters:**
+  * **scene_name** (*str*) – The name of the scene, used in the name of the log file.
+  * **module_name** (*str*) – The name of the module, used in the name of the log file.
+  * **log_dir** (*Path*) – Path to the folder where log files are stored.
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim._config.md

@@ -0,0 +1,33 @@
+# \_config
+
+Set the global config and logger.
+
+### Functions
+
+### tempconfig(temp)
+
+Context manager that temporarily modifies the global `config` object.
+
+Inside the `with` statement, the modified config will be used.  After
+context manager exits, the config will be restored to its original state.
+
+* **Parameters:**
+  **temp** ([*ManimConfig*](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig) *|* *dict* *[**str* *,* *Any* *]*) – Object whose keys will be used to temporarily update the global
+  `config`.
+* **Return type:**
+  *Generator*[None, None, None]
+
+### Examples
+
+Use `with tempconfig({...})` to temporarily change the default values of
+certain config options.
+
+```pycon
+>>> config["frame_height"]
+8.0
+>>> with tempconfig({"frame_height": 100.0}):
+...     print(config["frame_height"])
+100.0
+>>> config["frame_height"]
+8.0
+```

data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimConfig.md

@@ -0,0 +1,838 @@
+# ManimConfig
+
+Qualified name: `manim.\_config.utils.ManimConfig`
+
+### *class* ManimConfig
+
+Bases: `MutableMapping`
+
+Dict-like class storing all config options.
+
+The global `config` object is an instance of this class, and acts as a
+single source of truth for all of the library’s customizable behavior.
+
+The global `config` object is capable of digesting different types of
+sources and converting them into a uniform interface.  These sources are
+(in ascending order of precedence): configuration files, command line
+arguments, and programmatic changes.  Regardless of how the user chooses to
+set a config option, she can access its current value using
+[`ManimConfig`](#manim._config.utils.ManimConfig)’s attributes and properties.
+
+### Notes
+
+Each config option is implemented as a property of this class.
+
+Each config option can be set via a config file, using the full name of the
+property.  If a config option has an associated CLI flag, then the flag is
+equal to the full name of the property.  Those that admit an alternative
+flag or no flag at all are documented in the individual property’s
+docstring.
+
+### Examples
+
+We use a copy of the global configuration object in the following
+examples for the sake of demonstration; you can skip these lines
+and just import `config` directly if you actually want to modify
+the configuration:
+
+```pycon
+>>> from manim import config as global_config
+>>> config = global_config.copy()
+```
+
+Each config option allows for dict syntax and attribute syntax.  For
+example, the following two lines are equivalent,
+
+```pycon
+>>> from manim import WHITE
+>>> config.background_color = WHITE
+>>> config["background_color"] = WHITE
+```
+
+The former is preferred; the latter is provided mostly for backwards
+compatibility.
+
+The config options are designed to keep internal consistency.  For example,
+setting `frame_y_radius` will affect `frame_height`:
+
+```pycon
+>>> config.frame_height
+8.0
+>>> config.frame_y_radius = 5.0
+>>> config.frame_height
+10.0
+```
+
+There are many ways of interacting with config options.  Take for example
+the config option `background_color`.  There are three ways to change it:
+via a config file, via CLI flags, or programmatically.
+
+To set the background color via a config file, save the following
+`manim.cfg` file with the following contents.
+
+```default
+[CLI]
+background_color = WHITE
+```
+
+In order to have this `.cfg` file apply to a manim scene, it needs to be
+placed in the same directory as the script,
+
+```bash
+project/
+├─scene.py
+└─manim.cfg
+```
+
+Now, when the user executes
+
+```bash
+manim scene.py
+```
+
+the background of the scene will be set to `WHITE`.  This applies regardless
+of where the manim command is invoked from.
+
+Command line arguments override `.cfg` files.  In the previous example,
+executing
+
+```bash
+manim scene.py -c BLUE
+```
+
+will set the background color to BLUE, regardless of the contents of
+`manim.cfg`.
+
+Finally, any programmatic changes made within the scene script itself will
+override the command line arguments.  For example, if `scene.py` contains
+the following
+
+```python
+from manim import *
+
+config.background_color = RED
+
+class MyScene(Scene): ...
+```
+
+the background color will be set to RED, regardless of the contents of
+`manim.cfg` or the CLI arguments used when invoking manim.
+
+### Methods
+
+| [`copy`](#manim._config.utils.ManimConfig.copy)                   | Deepcopy the contents of this ManimConfig.                                                          |
+|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
+| [`digest_args`](#manim._config.utils.ManimConfig.digest_args)     | Process the config options present in CLI arguments.                                                |
+| [`digest_file`](#manim._config.utils.ManimConfig.digest_file)     | Process the config options present in a `.cfg` file.                                                |
+| [`digest_parser`](#manim._config.utils.ManimConfig.digest_parser) | Process the config options present in a `ConfigParser` object.                                      |
+| [`get_dir`](#manim._config.utils.ManimConfig.get_dir)             | Resolve a config option that stores a directory.                                                    |
+| `resolve_movie_file_extension`                                    |                                                                                                     |
+| [`update`](#manim._config.utils.ManimConfig.update)               | Digest the options found in another [`ManimConfig`](#manim._config.utils.ManimConfig) or in a dict. |
+
+### Attributes
+
+| [`aspect_ratio`](#manim._config.utils.ManimConfig.aspect_ratio)                                   | Aspect ratio (width / height) in pixels (--resolution, -r).                              |
+|---------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| [`assets_dir`](#manim._config.utils.ManimConfig.assets_dir)                                       | Directory to locate video assets (no flag).                                              |
+| [`background_color`](#manim._config.utils.ManimConfig.background_color)                           | Background color of the scene (-c).                                                      |
+| [`background_opacity`](#manim._config.utils.ManimConfig.background_opacity)                       | A number between 0.0 (fully transparent) and 1.0 (fully opaque).                         |
+| [`bottom`](#manim._config.utils.ManimConfig.bottom)                                               | Coordinate at the center bottom of the frame.                                            |
+| [`custom_folders`](#manim._config.utils.ManimConfig.custom_folders)                               | Whether to use custom folder output.                                                     |
+| [`disable_caching`](#manim._config.utils.ManimConfig.disable_caching)                             | Whether to use scene caching.                                                            |
+| [`disable_caching_warning`](#manim._config.utils.ManimConfig.disable_caching_warning)             | Whether a warning is raised if there are too much submobjects to hash.                   |
+| [`dry_run`](#manim._config.utils.ManimConfig.dry_run)                                             | Whether dry run is enabled.                                                              |
+| [`enable_gui`](#manim._config.utils.ManimConfig.enable_gui)                                       | Enable GUI interaction.                                                                  |
+| [`enable_wireframe`](#manim._config.utils.ManimConfig.enable_wireframe)                           | Whether to enable wireframe debugging mode in opengl.                                    |
+| [`ffmpeg_loglevel`](#manim._config.utils.ManimConfig.ffmpeg_loglevel)                             | Verbosity level of ffmpeg (no flag).                                                     |
+| [`flush_cache`](#manim._config.utils.ManimConfig.flush_cache)                                     | Whether to delete all the cached partial movie files.                                    |
+| [`force_window`](#manim._config.utils.ManimConfig.force_window)                                   | Whether to force window when using the opengl renderer.                                  |
+| [`format`](#manim._config.utils.ManimConfig.format)                                               | File format; "png", "gif", "mp4", "webm" or "mov".                                       |
+| [`frame_height`](#manim._config.utils.ManimConfig.frame_height)                                   | Frame height in logical units (no flag).                                                 |
+| [`frame_rate`](#manim._config.utils.ManimConfig.frame_rate)                                       | Frame rate in frames per second.                                                         |
+| [`frame_size`](#manim._config.utils.ManimConfig.frame_size)                                       | Tuple with (pixel width, pixel height) (no flag).                                        |
+| [`frame_width`](#manim._config.utils.ManimConfig.frame_width)                                     | Frame width in logical units (no flag).                                                  |
+| [`frame_x_radius`](#manim._config.utils.ManimConfig.frame_x_radius)                               | Half the frame width (no flag).                                                          |
+| [`frame_y_radius`](#manim._config.utils.ManimConfig.frame_y_radius)                               | Half the frame height (no flag).                                                         |
+| [`from_animation_number`](#manim._config.utils.ManimConfig.from_animation_number)                 | Start rendering animations at this number (-n).                                          |
+| [`fullscreen`](#manim._config.utils.ManimConfig.fullscreen)                                       | Expand the window to its maximum possible size.                                          |
+| [`gui_location`](#manim._config.utils.ManimConfig.gui_location)                                   | Enable GUI interaction.                                                                  |
+| [`images_dir`](#manim._config.utils.ManimConfig.images_dir)                                       | Directory to place images (no flag).                                                     |
+| [`input_file`](#manim._config.utils.ManimConfig.input_file)                                       | Input file name.                                                                         |
+| [`left_side`](#manim._config.utils.ManimConfig.left_side)                                         | Coordinate at the middle left of the frame.                                              |
+| [`log_dir`](#manim._config.utils.ManimConfig.log_dir)                                             | Directory to place logs.                                                                 |
+| [`log_to_file`](#manim._config.utils.ManimConfig.log_to_file)                                     | Whether to save logs to a file.                                                          |
+| [`max_files_cached`](#manim._config.utils.ManimConfig.max_files_cached)                           | Maximum number of files cached.                                                          |
+| [`media_dir`](#manim._config.utils.ManimConfig.media_dir)                                         | Main output directory.                                                                   |
+| [`media_embed`](#manim._config.utils.ManimConfig.media_embed)                                     | Whether to embed videos in Jupyter notebook.                                             |
+| [`media_width`](#manim._config.utils.ManimConfig.media_width)                                     | Media width in Jupyter notebook.                                                         |
+| [`movie_file_extension`](#manim._config.utils.ManimConfig.movie_file_extension)                   | Either .mp4, .webm or .mov.                                                              |
+| [`no_latex_cleanup`](#manim._config.utils.ManimConfig.no_latex_cleanup)                           | Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.             |
+| [`notify_outdated_version`](#manim._config.utils.ManimConfig.notify_outdated_version)             | Whether to notify if there is a version update available.                                |
+| [`output_file`](#manim._config.utils.ManimConfig.output_file)                                     | Output file name (-o).                                                                   |
+| [`partial_movie_dir`](#manim._config.utils.ManimConfig.partial_movie_dir)                         | Directory to place partial movie files (no flag).                                        |
+| [`pixel_height`](#manim._config.utils.ManimConfig.pixel_height)                                   | Frame height in pixels (--resolution, -r).                                               |
+| [`pixel_width`](#manim._config.utils.ManimConfig.pixel_width)                                     | Frame width in pixels (--resolution, -r).                                                |
+| [`plugins`](#manim._config.utils.ManimConfig.plugins)                                             | List of plugins to enable.                                                               |
+| [`preview`](#manim._config.utils.ManimConfig.preview)                                             | Whether to play the rendered movie (-p).                                                 |
+| `preview_command`                                                                                 |                                                                                          |
+| [`progress_bar`](#manim._config.utils.ManimConfig.progress_bar)                                   | Whether to show progress bars while rendering animations.                                |
+| [`quality`](#manim._config.utils.ManimConfig.quality)                                             | Video quality (-q).                                                                      |
+| [`renderer`](#manim._config.utils.ManimConfig.renderer)                                           | The currently active renderer.                                                           |
+| [`right_side`](#manim._config.utils.ManimConfig.right_side)                                       | Coordinate at the middle right of the frame.                                             |
+| [`save_as_gif`](#manim._config.utils.ManimConfig.save_as_gif)                                     | Whether to save the rendered scene in .gif format (-i).                                  |
+| [`save_last_frame`](#manim._config.utils.ManimConfig.save_last_frame)                             | Whether to save the last frame of the scene as an image file (-s).                       |
+| [`save_pngs`](#manim._config.utils.ManimConfig.save_pngs)                                         | Whether to save all frames in the scene as images files (-g).                            |
+| [`save_sections`](#manim._config.utils.ManimConfig.save_sections)                                 | Whether to save single videos for each section in addition to the movie file.            |
+| [`scene_names`](#manim._config.utils.ManimConfig.scene_names)                                     | Scenes to play from file.                                                                |
+| [`sections_dir`](#manim._config.utils.ManimConfig.sections_dir)                                   | Directory to place section videos (no flag).                                             |
+| [`show_in_file_browser`](#manim._config.utils.ManimConfig.show_in_file_browser)                   | Whether to show the output file in the file browser (-f).                                |
+| [`tex_dir`](#manim._config.utils.ManimConfig.tex_dir)                                             | Directory to place tex (no flag).                                                        |
+| [`tex_template`](#manim._config.utils.ManimConfig.tex_template)                                   | Template used when rendering Tex.                                                        |
+| [`tex_template_file`](#manim._config.utils.ManimConfig.tex_template_file)                         | File to read Tex template from (no flag).                                                |
+| [`text_dir`](#manim._config.utils.ManimConfig.text_dir)                                           | Directory to place text (no flag).                                                       |
+| [`top`](#manim._config.utils.ManimConfig.top)                                                     | Coordinate at the center top of the frame.                                               |
+| [`transparent`](#manim._config.utils.ManimConfig.transparent)                                     | Whether the background opacity is less than 1.0 (-t).                                    |
+| [`upto_animation_number`](#manim._config.utils.ManimConfig.upto_animation_number)                 | Stop rendering animations at this number.                                                |
+| [`use_projection_fill_shaders`](#manim._config.utils.ManimConfig.use_projection_fill_shaders)     | Use shaders for OpenGLVMobject fill which are compatible with transformation matrices.   |
+| [`use_projection_stroke_shaders`](#manim._config.utils.ManimConfig.use_projection_stroke_shaders) | Use shaders for OpenGLVMobject stroke which are compatible with transformation matrices. |
+| [`verbosity`](#manim._config.utils.ManimConfig.verbosity)                                         | Logger verbosity; "DEBUG", "INFO", "WARNING", "ERROR", or "CRITICAL" (-v).               |
+| [`video_dir`](#manim._config.utils.ManimConfig.video_dir)                                         | Directory to place videos (no flag).                                                     |
+| [`window_monitor`](#manim._config.utils.ManimConfig.window_monitor)                               | The monitor on which the scene will be rendered.                                         |
+| [`window_position`](#manim._config.utils.ManimConfig.window_position)                             | Set the position of preview window.                                                      |
+| [`window_size`](#manim._config.utils.ManimConfig.window_size)                                     | The size of the opengl window.                                                           |
+| [`write_all`](#manim._config.utils.ManimConfig.write_all)                                         | Whether to render all scenes in the input file (-a).                                     |
+| [`write_to_movie`](#manim._config.utils.ManimConfig.write_to_movie)                               | Whether to render the scene to a movie file (-w).                                        |
+| [`zero_pad`](#manim._config.utils.ManimConfig.zero_pad)                                           | PNG zero padding.                                                                        |
+
+#### \_set_between(key, val, lo, hi)
+
+Set `key` to `val` if lo <= val <= hi.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*float*)
+  * **lo** (*float*)
+  * **hi** (*float*)
+* **Return type:**
+  None
+
+#### \_set_boolean(key, val)
+
+Set `key` to `val` if `val` is Boolean.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*Any*)
+* **Return type:**
+  None
+
+#### \_set_from_enum(key, enum_value, enum_class)
+
+Set `key` to the enum object with value `enum_value` in the given
+`enum_class`.
+
+Tests:
+
+```default
+>>> from enum import Enum
+>>> class Fruit(Enum):
+...     APPLE = 1
+...     BANANA = 2
+...     CANTALOUPE = 3
+>>> test_config = ManimConfig()
+>>> test_config._set_from_enum("fruit", 1, Fruit)
+>>> test_config._d['fruit']
+<Fruit.APPLE: 1>
+>>> test_config._set_from_enum("fruit", Fruit.BANANA, Fruit)
+>>> test_config._d['fruit']
+<Fruit.BANANA: 2>
+>>> test_config._set_from_enum("fruit", 42, Fruit)
+Traceback (most recent call last):
+...
+ValueError: 42 is not a valid Fruit
+```
+
+* **Parameters:**
+  * **key** (*str*)
+  * **enum_value** (*Any*)
+  * **enum_class** (*EnumMeta*)
+* **Return type:**
+  None
+
+#### \_set_from_list(key, val, values)
+
+Set `key` to `val` if `val` is contained in `values`.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*Any*)
+  * **values** (*list* *[**Any* *]*)
+* **Return type:**
+  None
+
+#### \_set_int_between(key, val, lo, hi)
+
+Set `key` to `val` if lo <= val <= hi.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*int*)
+  * **lo** (*int*)
+  * **hi** (*int*)
+* **Return type:**
+  None
+
+#### \_set_pos_number(key, val, allow_inf)
+
+Set `key` to `val` if `val` is a positive integer.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*int*)
+  * **allow_inf** (*bool*)
+* **Return type:**
+  None
+
+#### \_set_str(key, val)
+
+Set `key` to `val` if `val` is a string.
+
+* **Parameters:**
+  * **key** (*str*)
+  * **val** (*Any*)
+* **Return type:**
+  None
+
+#### *property* aspect_ratio *: int*
+
+Aspect ratio (width / height) in pixels (–resolution, -r).
+
+#### *property* assets_dir *: str*
+
+Directory to locate video assets (no flag).
+
+#### *property* background_color *: [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)*
+
+Background color of the scene (-c).
+
+#### *property* background_opacity *: float*
+
+A number between 0.0 (fully transparent) and 1.0 (fully opaque).
+
+#### *property* bottom *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the center bottom of the frame.
+
+#### copy()
+
+Deepcopy the contents of this ManimConfig.
+
+* **Returns:**
+  A copy of this object containing no shared references.
+* **Return type:**
+  [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+`tempconfig()`
+
+### Notes
+
+This is the main mechanism behind `tempconfig()`.
+
+#### *property* custom_folders *: str*
+
+Whether to use custom folder output.
+
+#### digest_args(args)
+
+Process the config options present in CLI arguments.
+
+* **Parameters:**
+  **args** (*argparse.Namespace*) – An object returned by `main_utils.parse_args()`.
+* **Returns:**
+  **self** – This object, after processing the contents of `parser`.
+* **Return type:**
+  [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+`main_utils.parse_args()`, [`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser),
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file)
+
+### Notes
+
+If `args.config_file` is a non-empty string, `ManimConfig` tries to digest the
+contents of said file with [`digest_file()`](#manim._config.utils.ManimConfig.digest_file) before
+digesting any other CLI arguments.
+
+#### digest_file(filename)
+
+Process the config options present in a `.cfg` file.
+
+This method processes a single `.cfg` file, whereas
+[`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser) can process arbitrary parsers, built
+perhaps from multiple `.cfg` files.
+
+* **Parameters:**
+  **filename** ([*StrPath*](manim.typing.md#manim.typing.StrPath)) – Path to the `.cfg` file.
+* **Returns:**
+  **self** – This object, after processing the contents of `filename`.
+* **Return type:**
+  [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args), [`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser)
+
+### Notes
+
+If there are multiple `.cfg` files to process, it is always more
+efficient to parse them into a single `ConfigParser` object
+first and digesting them with one call to
+[`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser), instead of calling this method
+multiple times.
+
+#### digest_parser(parser)
+
+Process the config options present in a `ConfigParser` object.
+
+This method processes arbitrary parsers, not only those read from a
+single file, whereas [`digest_file()`](#manim._config.utils.ManimConfig.digest_file) can only process one
+file at a time.
+
+* **Parameters:**
+  **parser** (*configparser.ConfigParser*) – An object reflecting the contents of one or many `.cfg` files.  In
+  particular, it may reflect the contents of multiple files that have
+  been parsed in a cascading fashion.
+* **Returns:**
+  **self** – This object, after processing the contents of `parser`.
+* **Return type:**
+  [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+[`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser), [`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args)
+
+### Notes
+
+If there are multiple `.cfg` files to process, it is always more
+efficient to parse them into a single `ConfigParser` object
+first, and then call this function once (instead of calling
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file) multiple times).
+
+### Examples
+
+To digest the config options set in two files, first create a
+ConfigParser and parse both files and then digest the parser:
+
+```python
+parser = configparser.ConfigParser()
+parser.read([file1, file2])
+config = ManimConfig().digest_parser(parser)
+```
+
+In fact, the global `config` object is initialized like so:
+
+```python
+parser = make_config_parser()
+config = ManimConfig().digest_parser(parser)
+```
+
+#### *property* disable_caching *: bool*
+
+Whether to use scene caching.
+
+#### *property* disable_caching_warning *: bool*
+
+Whether a warning is raised if there are too much submobjects to hash.
+
+#### *property* dry_run *: bool*
+
+Whether dry run is enabled.
+
+#### *property* enable_gui *: bool*
+
+Enable GUI interaction.
+
+#### *property* enable_wireframe *: bool*
+
+Whether to enable wireframe debugging mode in opengl.
+
+#### *property* ffmpeg_loglevel *: str*
+
+Verbosity level of ffmpeg (no flag).
+
+#### *property* flush_cache *: bool*
+
+Whether to delete all the cached partial movie files.
+
+#### *property* force_window *: bool*
+
+Whether to force window when using the opengl renderer.
+
+#### *property* format *: str*
+
+File format; “png”, “gif”, “mp4”, “webm” or “mov”.
+
+#### *property* frame_height *: float*
+
+Frame height in logical units (no flag).
+
+#### *property* frame_rate *: float*
+
+Frame rate in frames per second.
+
+#### *property* frame_size *: tuple[int, int]*
+
+Tuple with (pixel width, pixel height) (no flag).
+
+#### *property* frame_width *: float*
+
+Frame width in logical units (no flag).
+
+#### *property* frame_x_radius *: float*
+
+Half the frame width (no flag).
+
+#### *property* frame_y_radius *: float*
+
+Half the frame height (no flag).
+
+#### *property* from_animation_number *: int*
+
+Start rendering animations at this number (-n).
+
+#### *property* fullscreen *: bool*
+
+Expand the window to its maximum possible size.
+
+#### get_dir(key, \*\*kwargs)
+
+Resolve a config option that stores a directory.
+
+Config options that store directories may depend on one another.  This
+method is used to provide the actual directory to the end user.
+
+* **Parameters:**
+  * **key** (*str*) – The config option to be resolved.  Must be an option ending in
+    `'_dir'`, for example `'media_dir'` or `'video_dir'`.
+  * **kwargs** (*Any*) – Any strings to be used when resolving the directory.
+* **Returns:**
+  Path to the requested directory.  If the path resolves to the empty
+  string, return `None` instead.
+* **Return type:**
+  `pathlib.Path`
+* **Raises:**
+  **KeyError** – When `key` is not a config option that stores a directory and
+      thus [`get_dir()`](#manim._config.utils.ManimConfig.get_dir) is not appropriate; or when
+      `key` is appropriate but there is not enough information to
+      resolve the directory.
+
+### Notes
+
+Standard `str.format()` syntax is used to resolve the paths so the
+paths may contain arbitrary placeholders using f-string notation.
+However, these will require `kwargs` to contain the required values.
+
+### Examples
+
+The value of `config.tex_dir` is `'{media_dir}/Tex'` by default,
+i.e. it is a subfolder of wherever `config.media_dir` is located.  In
+order to get the *actual* directory, use [`get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+```pycon
+>>> from manim import config as globalconfig
+>>> config = globalconfig.copy()
+>>> config.tex_dir
+'{media_dir}/Tex'
+>>> config.media_dir
+'./media'
+>>> config.get_dir("tex_dir").as_posix()
+'media/Tex'
+```
+
+Resolving directories is done in a lazy way, at the last possible
+moment, to reflect any changes in other config options:
+
+```pycon
+>>> config.media_dir = "my_media_dir"
+>>> config.get_dir("tex_dir").as_posix()
+'my_media_dir/Tex'
+```
+
+Some directories depend on information that is not available to
+[`ManimConfig`](#manim._config.utils.ManimConfig). For example, the default value of video_dir
+includes the name of the input file and the video quality
+(e.g. 480p15). This informamtion has to be supplied via `kwargs`:
+
+```pycon
+>>> config.video_dir
+'{media_dir}/videos/{module_name}/{quality}'
+>>> config.get_dir("video_dir")
+Traceback (most recent call last):
+KeyError: 'video_dir {media_dir}/videos/{module_name}/{quality} requires the following keyword arguments: module_name'
+>>> config.get_dir("video_dir", module_name="myfile").as_posix()
+'my_media_dir/videos/myfile/1080p60'
+```
+
+Note the quality does not need to be passed as keyword argument since
+[`ManimConfig`](#manim._config.utils.ManimConfig) does store information about quality.
+
+Directories may be recursively defined.  For example, the config option
+`partial_movie_dir` depends on `video_dir`, which in turn depends
+on `media_dir`:
+
+```pycon
+>>> config.partial_movie_dir
+'{video_dir}/partial_movie_files/{scene_name}'
+>>> config.get_dir("partial_movie_dir")
+Traceback (most recent call last):
+KeyError: 'partial_movie_dir {video_dir}/partial_movie_files/{scene_name} requires the following keyword arguments: scene_name'
+>>> config.get_dir(
+...     "partial_movie_dir", module_name="myfile", scene_name="myscene"
+... ).as_posix()
+'my_media_dir/videos/myfile/1080p60/partial_movie_files/myscene'
+```
+
+Standard f-string syntax is used.  Arbitrary names can be used when
+defining directories, as long as the corresponding values are passed to
+[`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir) via `kwargs`.
+
+```pycon
+>>> config.media_dir = "{dir1}/{dir2}"
+>>> config.get_dir("media_dir")
+Traceback (most recent call last):
+KeyError: 'media_dir {dir1}/{dir2} requires the following keyword arguments: dir1'
+>>> config.get_dir("media_dir", dir1="foo", dir2="bar").as_posix()
+'foo/bar'
+>>> config.media_dir = "./media"
+>>> config.get_dir("media_dir").as_posix()
+'media'
+```
+
+#### *property* gui_location *: tuple[Any]*
+
+Enable GUI interaction.
+
+#### *property* images_dir *: str*
+
+Directory to place images (no flag).  See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* input_file *: str*
+
+Input file name.
+
+#### *property* left_side *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the middle left of the frame.
+
+#### *property* log_dir *: str*
+
+Directory to place logs. See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* log_to_file *: bool*
+
+Whether to save logs to a file.
+
+#### *property* max_files_cached *: int*
+
+Maximum number of files cached.  Use -1 for infinity (no flag).
+
+#### *property* media_dir *: str*
+
+Main output directory.  See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* media_embed *: bool*
+
+Whether to embed videos in Jupyter notebook.
+
+#### *property* media_width *: str*
+
+Media width in Jupyter notebook.
+
+#### *property* movie_file_extension *: str*
+
+Either .mp4, .webm or .mov.
+
+#### *property* no_latex_cleanup *: bool*
+
+Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.
+
+#### *property* notify_outdated_version *: bool*
+
+Whether to notify if there is a version update available.
+
+#### *property* output_file *: str*
+
+Output file name (-o).
+
+#### *property* partial_movie_dir *: str*
+
+Directory to place partial movie files (no flag).  See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* pixel_height *: int*
+
+Frame height in pixels (–resolution, -r).
+
+#### *property* pixel_width *: int*
+
+Frame width in pixels (–resolution, -r).
+
+#### *property* plugins *: list[str]*
+
+List of plugins to enable.
+
+#### *property* preview *: bool*
+
+Whether to play the rendered movie (-p).
+
+#### *property* progress_bar *: str*
+
+Whether to show progress bars while rendering animations.
+
+#### *property* quality *: str | None*
+
+Video quality (-q).
+
+#### *property* renderer *: [RendererType](manim.constants.RendererType.md#manim.constants.RendererType)*
+
+The currently active renderer.
+
+Populated with one of the available renderers in [`RendererType`](manim.constants.RendererType.md#manim.constants.RendererType).
+
+Tests:
+
+```default
+>>> test_config = ManimConfig()
+>>> test_config.renderer is None  # a new ManimConfig is unpopulated
+True
+>>> test_config.renderer = 'opengl'
+>>> test_config.renderer
+<RendererType.OPENGL: 'opengl'>
+>>> test_config.renderer = 42
+Traceback (most recent call last):
+...
+ValueError: 42 is not a valid RendererType
+```
+
+Check that capitalization of renderer types is irrelevant:
+
+```default
+>>> test_config.renderer = 'OpenGL'
+>>> test_config.renderer = 'cAirO'
+```
+
+#### *property* right_side *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the middle right of the frame.
+
+#### *property* save_as_gif *: bool*
+
+Whether to save the rendered scene in .gif format (-i).
+
+#### *property* save_last_frame *: bool*
+
+Whether to save the last frame of the scene as an image file (-s).
+
+#### *property* save_pngs *: bool*
+
+Whether to save all frames in the scene as images files (-g).
+
+#### *property* save_sections *: bool*
+
+Whether to save single videos for each section in addition to the movie file.
+
+#### *property* scene_names *: list[str]*
+
+Scenes to play from file.
+
+#### *property* sections_dir *: str*
+
+Directory to place section videos (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* show_in_file_browser *: bool*
+
+Whether to show the output file in the file browser (-f).
+
+#### *property* tex_dir *: str*
+
+Directory to place tex (no flag).  See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* tex_template *: [TexTemplate](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate)*
+
+Template used when rendering Tex.  See [`TexTemplate`](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate).
+
+#### *property* tex_template_file *: Path*
+
+File to read Tex template from (no flag).  See [`TexTemplate`](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate).
+
+#### *property* text_dir *: str*
+
+Directory to place text (no flag).  See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* top *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the center top of the frame.
+
+#### *property* transparent *: bool*
+
+Whether the background opacity is less than 1.0 (-t).
+
+#### update(obj)
+
+Digest the options found in another [`ManimConfig`](#manim._config.utils.ManimConfig) or in a dict.
+
+Similar to `dict.update()`, replaces the values of this object with
+those of `obj`.
+
+* **Parameters:**
+  **obj** ([*ManimConfig*](#manim._config.utils.ManimConfig) *|* *dict* *[**str* *,* *Any* *]*) – The object to copy values from.
+* **Return type:**
+  None
+* **Raises:**
+  **AttributeError** – If `obj` is a dict but contains keys that do not belong to any
+      config options.
+
+#### SEE ALSO
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args), [`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser)
+
+#### *property* upto_animation_number *: int*
+
+Stop rendering animations at this number. Use -1 to avoid skipping (-n).
+
+#### *property* use_projection_fill_shaders *: bool*
+
+Use shaders for OpenGLVMobject fill which are compatible with transformation matrices.
+
+#### *property* use_projection_stroke_shaders *: bool*
+
+Use shaders for OpenGLVMobject stroke which are compatible with transformation matrices.
+
+#### *property* verbosity *: str*
+
+Logger verbosity; “DEBUG”, “INFO”, “WARNING”, “ERROR”, or “CRITICAL” (-v).
+
+#### *property* video_dir *: str*
+
+Directory to place videos (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* window_monitor *: int*
+
+The monitor on which the scene will be rendered.
+
+#### *property* window_position *: str*
+
+Set the position of preview window. You can use directions, e.g. UL/DR/ORIGIN/LEFT…or the position(pixel) of the upper left corner of the window, e.g. ‘960,540’.
+
+#### *property* window_size *: str*
+
+The size of the opengl window. ‘default’ to automatically scale the window based on the display monitor.
+
+#### *property* write_all *: bool*
+
+Whether to render all scenes in the input file (-a).
+
+#### *property* write_to_movie *: bool*
+
+Whether to render the scene to a movie file (-w).
+
+#### *property* zero_pad *: int*
+
+PNG zero padding. A number between 0 (no zero padding) and 9 (9 columns minimum).

data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimFrame.md

@@ -0,0 +1,40 @@
+# ManimFrame
+
+Qualified name: `manim.\_config.utils.ManimFrame`
+
+### *class* ManimFrame(c)
+
+Bases: `Mapping`
+
+### Methods
+
+### Attributes
+
+| `DL`             |    |
+|------------------|----|
+| `DOWN`           |    |
+| `DR`             |    |
+| `IN`             |    |
+| `LEFT`           |    |
+| `ORIGIN`         |    |
+| `OUT`            |    |
+| `RIGHT`          |    |
+| `UL`             |    |
+| `UP`             |    |
+| `UR`             |    |
+| `X_AXIS`         |    |
+| `Y_AXIS`         |    |
+| `Z_AXIS`         |    |
+| `aspect_ratio`   |    |
+| `bottom`         |    |
+| `frame_height`   |    |
+| `frame_width`    |    |
+| `frame_x_radius` |    |
+| `frame_y_radius` |    |
+| `left_side`      |    |
+| `pixel_height`   |    |
+| `pixel_width`    |    |
+| `right_side`     |    |
+| `top`            |    |
+* **Parameters:**
+  **c** ([*ManimConfig*](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig))

data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.md

@@ -0,0 +1,75 @@
+# utils
+
+Utilities to create and set the config.
+
+The main class exported by this module is [`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig).  This class
+contains all configuration options, including frame geometry (e.g. frame
+height/width, frame rate), output (e.g. directories, logging), styling
+(e.g. background color, transparency), and general behavior (e.g. writing a
+movie vs writing a single frame).
+
+See [Configuration](../guides/configuration.md) for an introduction to Manim’s configuration system.
+
+### Classes
+
+| [`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig)   | Dict-like class storing all config options.   |
+|---------------------------------------------------------------------------------------|-----------------------------------------------|
+| [`ManimFrame`](manim._config.utils.ManimFrame.md#manim._config.utils.ManimFrame)      |                                               |
+
+### Functions
+
+### config_file_paths()
+
+The paths where `.cfg` files will be searched for.
+
+When manim is first imported, it processes any `.cfg` files it finds.  This
+function returns the locations in which these files are searched for.  In
+ascending order of precedence, these are: the library-wide config file, the
+user-wide config file, and the folder-wide config file.
+
+The library-wide config file determines manim’s default behavior.  The
+user-wide config file is stored in the user’s home folder, and determines
+the behavior of manim whenever the user invokes it from anywhere in the
+system.  The folder-wide config file only affects scenes that are in the
+same folder.  The latter two files are optional.
+
+These files, if they exist, are meant to loaded into a single
+`configparser.ConfigParser` object, and then processed by
+[`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig).
+
+* **Returns:**
+  List of paths which may contain `.cfg` files, in ascending order of
+  precedence.
+* **Return type:**
+  List[`Path`]
+
+#### SEE ALSO
+[`make_config_parser()`](#manim._config.utils.make_config_parser), [`ManimConfig.digest_file()`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig.digest_file), [`ManimConfig.digest_parser()`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig.digest_parser)
+
+### Notes
+
+The location of the user-wide config file is OS-specific.
+
+### make_config_parser(custom_file=None)
+
+Make a `ConfigParser` object and load any `.cfg` files.
+
+The user-wide file, if it exists, overrides the library-wide file.  The
+folder-wide file, if it exists, overrides the other two.
+
+The folder-wide file can be ignored by passing `custom_file`.  However,
+the user-wide and library-wide config files cannot be ignored.
+
+* **Parameters:**
+  **custom_file** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *None*) – Path to a custom config file.  If used, the folder-wide file in the
+  relevant directory will be ignored, if it exists.  If None, the
+  folder-wide file will be used, if it exists.
+* **Returns:**
+  A parser containing the config options found in the .cfg files that
+  were found.  It is guaranteed to contain at least the config options
+  found in the library-wide file.
+* **Return type:**
+  `ConfigParser`
+
+#### SEE ALSO
+[`config_file_paths()`](#manim._config.utils.config_file_paths)

data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Add.md

@@ -0,0 +1,206 @@
+# Add
+
+Qualified name: `manim.animation.animation.Add`
+
+### *class* Add(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Add Mobjects to a scene, without animating them in any other way. This
+is similar to the [`Scene.add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) method, but [`Add`](#manim.animation.animation.Add) is an
+animation which can be grouped into other animations.
+
+* **Parameters:**
+  * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – One [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) or more to add to a scene.
+  * **run_time** (*float*) – The duration of the animation after adding the `mobjects`. Defaults
+    to 0, which means this is an instant animation without extra wait time
+    after adding them.
+  * **\*\*kwargs** (*Any*) – Additional arguments to pass to the parent [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) class.
+
+### Examples
+
+<div id="defaultaddscene" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: DefaultAddScene <a class="headerlink" href="#defaultaddscene">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./DefaultAddScene-1.mp4">
+</video>
+```python
+from manim import *
+
+class DefaultAddScene(Scene):
+    def construct(self):
+        text_1 = Text("I was added with Add!")
+        text_2 = Text("Me too!")
+        text_3 = Text("And me!")
+        texts = VGroup(text_1, text_2, text_3).arrange(DOWN)
+        rect = SurroundingRectangle(texts, buff=0.5)
+
+        self.play(
+            Create(rect, run_time=3.0),
+            Succession(
+                Wait(1.0),
+                # You can Add a Mobject in the middle of an animation...
+                Add(text_1),
+                Wait(1.0),
+                # ...or multiple Mobjects at once!
+                Add(text_2, text_3),
+            ),
+        )
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="DefaultAddScene">
+class DefaultAddScene(Scene):
+    def construct(self):
+        text_1 = Text("I was added with Add!")
+        text_2 = Text("Me too!")
+        text_3 = Text("And me!")
+        texts = VGroup(text_1, text_2, text_3).arrange(DOWN)
+        rect = SurroundingRectangle(texts, buff=0.5)
+
+        self.play(
+            Create(rect, run_time=3.0),
+            Succession(
+                Wait(1.0),
+                # You can Add a Mobject in the middle of an animation...
+                Add(text_1),
+                Wait(1.0),
+                # ...or multiple Mobjects at once!
+                Add(text_2, text_3),
+            ),
+        )
+        self.wait()
+
+</pre></div><div id="addwithruntimescene" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: AddWithRunTimeScene <a class="headerlink" href="#addwithruntimescene">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./AddWithRunTimeScene-1.mp4">
+</video>
+```python
+from manim import *
+
+class AddWithRunTimeScene(Scene):
+    def construct(self):
+        # A 5x5 grid of circles
+        circles = VGroup(
+            *[Circle(radius=0.5) for _ in range(25)]
+        ).arrange_in_grid(5, 5)
+
+        self.play(
+            Succession(
+                # Add a run_time of 0.2 to wait for 0.2 seconds after
+                # adding the circle, instead of using Wait(0.2) after Add!
+                *[Add(circle, run_time=0.2) for circle in circles],
+                rate_func=smooth,
+            )
+        )
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="AddWithRunTimeScene">
+class AddWithRunTimeScene(Scene):
+    def construct(self):
+        # A 5x5 grid of circles
+        circles = VGroup(
+            \*[Circle(radius=0.5) for \_ in range(25)]
+        ).arrange_in_grid(5, 5)
+
+        self.play(
+            Succession(
+                # Add a run_time of 0.2 to wait for 0.2 seconds after
+                # adding the circle, instead of using Wait(0.2) after Add!
+                \*[Add(circle, run_time=0.2) for circle in circles],
+                rate_func=smooth,
+            )
+        )
+        self.wait()
+
+</pre></div>
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Add.begin)                             | Begin the animation.                                                                                      |
+|-----------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Add.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.animation.Add.finish)                           | Finish the animation.                                                                                     |
+| [`interpolate`](#manim.animation.animation.Add.interpolate)                 | Set the animation progress.                                                                               |
+| [`update_mobjects`](#manim.animation.animation.Add.update_mobjects)         | Updates things like starting_mobject, and (for Transforms) target_mobject.                                |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(\*mobjects, run_time=0.0, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **run_time** (*float*)
+  * **kwargs** (*Any*)
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+  **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+  the end.
+* **Return type:**
+  None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject.  Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+  **dt** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Animation.md

@@ -0,0 +1,400 @@
+# Animation
+
+Qualified name: `manim.animation.animation.Animation`
+
+### *class* Animation(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `object`
+
+An animation.
+
+Animations have a fixed time span.
+
+* **Parameters:**
+  * **mobject** – The mobject to be animated. This is not required for all types of animations.
+  * **lag_ratio** – 
+
+    Defines the delay after which the animation is applied to submobjects. This lag
+    is relative to the duration of the animation.
+
+    This does not influence the total
+    runtime of the animation. Instead the runtime of individual animations is
+    adjusted so that the complete animation has the defined run time.
+  * **run_time** – The duration of the animation in seconds.
+  * **rate_func** – 
+
+    The function defining the animation progress based on the relative runtime (see  [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)) .
+
+    For example `rate_func(0.5)` is the proportion of the animation that is done
+    after half of the animations run time.
+* **Return type:**
+  Self
+
+reverse_rate_function
+: Reverses the rate function of the animation. Setting `reverse_rate_function`
+  does not have any effect on `remover` or `introducer`. These need to be
+  set explicitly if an introducer-animation should be turned into a remover one
+  and vice versa.
+
+name
+: The name of the animation. This gets displayed while rendering the animation.
+  Defaults to <class-name>(<Mobject-name>).
+
+remover
+: Whether the given mobject should be removed from the scene after this animation.
+
+suspend_mobject_updating
+: Whether updaters of the mobject should be suspended during the animation.
+
+#### NOTE
+In the current implementation of this class, the specified rate function is applied
+within [`Animation.interpolate_mobject()`](#manim.animation.animation.Animation.interpolate_mobject) call as part of the call to
+`Animation.interpolate_submobject()`. For subclasses of [`Animation`](#manim.animation.animation.Animation)
+that are implemented by overriding [`interpolate_mobject()`](#manim.animation.animation.Animation.interpolate_mobject), the rate function
+has to be applied manually (e.g., by passing `self.rate_func(alpha)` instead
+of just `alpha`).
+
+### Examples
+
+<div id="lagratios" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LagRatios <a class="headerlink" href="#lagratios">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./LagRatios-1.mp4">
+</video>
+```python
+from manim import *
+
+class LagRatios(Scene):
+    def construct(self):
+        ratios = [0, 0.1, 0.5, 1, 2]  # demonstrated lag_ratios
+
+        # Create dot groups
+        group = VGroup(*[Dot() for _ in range(4)]).arrange_submobjects()
+        groups = VGroup(*[group.copy() for _ in ratios]).arrange_submobjects(buff=1)
+        self.add(groups)
+
+        # Label groups
+        self.add(Text("lag_ratio = ", font_size=36).next_to(groups, UP, buff=1.5))
+        for group, ratio in zip(groups, ratios):
+            self.add(Text(str(ratio), font_size=36).next_to(group, UP))
+
+        #Animate groups with different lag_ratios
+        self.play(AnimationGroup(*[
+            group.animate(lag_ratio=ratio, run_time=1.5).shift(DOWN * 2)
+            for group, ratio in zip(groups, ratios)
+        ]))
+
+        # lag_ratio also works recursively on nested submobjects:
+        self.play(groups.animate(run_time=1, lag_ratio=0.1).shift(UP * 2))
+```
+
+<pre data-manim-binder data-manim-classname="LagRatios">
+class LagRatios(Scene):
+    def construct(self):
+        ratios = [0, 0.1, 0.5, 1, 2]  # demonstrated lag_ratios
+
+        # Create dot groups
+        group = VGroup(\*[Dot() for \_ in range(4)]).arrange_submobjects()
+        groups = VGroup(\*[group.copy() for \_ in ratios]).arrange_submobjects(buff=1)
+        self.add(groups)
+
+        # Label groups
+        self.add(Text("lag_ratio = ", font_size=36).next_to(groups, UP, buff=1.5))
+        for group, ratio in zip(groups, ratios):
+            self.add(Text(str(ratio), font_size=36).next_to(group, UP))
+
+        #Animate groups with different lag_ratios
+        self.play(AnimationGroup(\*[
+            group.animate(lag_ratio=ratio, run_time=1.5).shift(DOWN \* 2)
+            for group, ratio in zip(groups, ratios)
+        ]))
+
+        # lag_ratio also works recursively on nested submobjects:
+        self.play(groups.animate(run_time=1, lag_ratio=0.1).shift(UP \* 2))
+
+</pre></div>
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Animation.begin)                                           | Begin the animation.                                                                                      |
+|-------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Animation.clean_up_from_scene)               | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`copy`](#manim.animation.animation.Animation.copy)                                             | Create a copy of the animation.                                                                           |
+| `create_starting_mobject`                                                                       |                                                                                                           |
+| [`finish`](#manim.animation.animation.Animation.finish)                                         | Finish the animation.                                                                                     |
+| `get_all_families_zipped`                                                                       |                                                                                                           |
+| [`get_all_mobjects`](#manim.animation.animation.Animation.get_all_mobjects)                     | Get all mobjects involved in the animation.                                                               |
+| [`get_all_mobjects_to_update`](#manim.animation.animation.Animation.get_all_mobjects_to_update) | Get all mobjects to be updated during the animation.                                                      |
+| [`get_rate_func`](#manim.animation.animation.Animation.get_rate_func)                           | Get the rate function of the animation.                                                                   |
+| [`get_run_time`](#manim.animation.animation.Animation.get_run_time)                             | Get the run time of the animation.                                                                        |
+| [`get_sub_alpha`](#manim.animation.animation.Animation.get_sub_alpha)                           | Get the animation progress of any submobjects subanimation.                                               |
+| [`interpolate`](#manim.animation.animation.Animation.interpolate)                               | Set the animation progress.                                                                               |
+| [`interpolate_mobject`](#manim.animation.animation.Animation.interpolate_mobject)               | Interpolates the mobject of the [`Animation`](#manim.animation.animation.Animation) based on alpha value. |
+| `interpolate_submobject`                                                                        |                                                                                                           |
+| [`is_introducer`](#manim.animation.animation.Animation.is_introducer)                           | Test if the animation is an introducer.                                                                   |
+| [`is_remover`](#manim.animation.animation.Animation.is_remover)                                 | Test if the animation is a remover.                                                                       |
+| [`set_default`](#manim.animation.animation.Animation.set_default)                               | Sets the default values of keyword arguments.                                                             |
+| [`set_name`](#manim.animation.animation.Animation.set_name)                                     | Set the name of the animation.                                                                            |
+| [`set_rate_func`](#manim.animation.animation.Animation.set_rate_func)                           | Set the rate function of the animation.                                                                   |
+| [`set_run_time`](#manim.animation.animation.Animation.set_run_time)                             | Set the run time of the animation.                                                                        |
+| [`update_mobjects`](#manim.animation.animation.Animation.update_mobjects)                       | Updates things like starting_mobject, and (for Transforms) target_mobject.                                |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### copy()
+
+Create a copy of the animation.
+
+* **Returns:**
+  A copy of `self`
+* **Return type:**
+  [Animation](#manim.animation.animation.Animation)
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+  The sequence of mobjects.
+* **Return type:**
+  Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### get_all_mobjects_to_update()
+
+Get all mobjects to be updated during the animation.
+
+* **Returns:**
+  The list of mobjects to be updated during the animation.
+* **Return type:**
+  List[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### get_rate_func()
+
+Get the rate function of the animation.
+
+* **Returns:**
+  The rate function of the animation.
+* **Return type:**
+  Callable[[float], float]
+
+#### get_run_time()
+
+Get the run time of the animation.
+
+* **Returns:**
+  The time the animation takes in seconds.
+* **Return type:**
+  float
+
+#### get_sub_alpha(alpha, index, num_submobjects)
+
+Get the animation progress of any submobjects subanimation.
+
+* **Parameters:**
+  * **alpha** (*float*) – The overall animation progress
+  * **index** (*int*) – The index of the subanimation.
+  * **num_submobjects** (*int*) – The total count of subanimations.
+* **Returns:**
+  The progress of the subanimation.
+* **Return type:**
+  float
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+  **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+  the end.
+* **Return type:**
+  None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the [`Animation`](#manim.animation.animation.Animation) based on alpha value.
+
+* **Parameters:**
+  **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+  is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+  to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+  None
+
+#### is_introducer()
+
+Test if the animation is an introducer.
+
+* **Returns:**
+  `True` if the animation is an introducer, `False` otherwise.
+* **Return type:**
+  bool
+
+#### is_remover()
+
+Test if the animation is a remover.
+
+* **Returns:**
+  `True` if the animation is a remover, `False` otherwise.
+* **Return type:**
+  bool
+
+#### *classmethod* set_default(\*\*kwargs)
+
+Sets the default values of keyword arguments.
+
+If this method is called without any additional keyword
+arguments, the original default values of the initialization
+method of this class are restored.
+
+* **Parameters:**
+  **kwargs** – Passing any keyword argument will update the default
+  values of the keyword arguments of the initialization
+  function of this class.
+* **Return type:**
+  None
+
+### Examples
+
+<div id="changedefaultanimation" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ChangeDefaultAnimation <a class="headerlink" href="#changedefaultanimation">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ChangeDefaultAnimation-1.mp4">
+</video>
+```python
+from manim import *
+
+class ChangeDefaultAnimation(Scene):
+    def construct(self):
+        Rotate.set_default(run_time=2, rate_func=rate_functions.linear)
+        Indicate.set_default(color=None)
+
+        S = Square(color=BLUE, fill_color=BLUE, fill_opacity=0.25)
+        self.add(S)
+        self.play(Rotate(S, PI))
+        self.play(Indicate(S))
+
+        Rotate.set_default()
+        Indicate.set_default()
+```
+
+<pre data-manim-binder data-manim-classname="ChangeDefaultAnimation">
+class ChangeDefaultAnimation(Scene):
+    def construct(self):
+        Rotate.set_default(run_time=2, rate_func=rate_functions.linear)
+        Indicate.set_default(color=None)
+
+        S = Square(color=BLUE, fill_color=BLUE, fill_opacity=0.25)
+        self.add(S)
+        self.play(Rotate(S, PI))
+        self.play(Indicate(S))
+
+        Rotate.set_default()
+        Indicate.set_default()
+
+</pre></div>
+
+#### set_name(name)
+
+Set the name of the animation.
+
+* **Parameters:**
+  **name** (*str*) – The new name of the animation.
+* **Returns:**
+  `self`
+* **Return type:**
+  [Animation](#manim.animation.animation.Animation)
+
+#### set_rate_func(rate_func)
+
+Set the rate function of the animation.
+
+* **Parameters:**
+  **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The new function defining the animation progress based on the
+  relative runtime (see [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)).
+* **Returns:**
+  `self`
+* **Return type:**
+  [Animation](#manim.animation.animation.Animation)
+
+#### set_run_time(run_time)
+
+Set the run time of the animation.
+
+* **Parameters:**
+  * **run_time** (*float*) – The new time the animation should take in seconds.
+  * **note::** ( *..*) – The run_time of an animation should not be changed while it is already
+    running.
+* **Returns:**
+  `self`
+* **Return type:**
+  [Animation](#manim.animation.animation.Animation)
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject.  Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+  **dt** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Wait.md

@@ -0,0 +1,105 @@
+# Wait
+
+Qualified name: `manim.animation.animation.Wait`
+
+### *class* Wait(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+A “no operation” animation.
+
+* **Parameters:**
+  * **run_time** (*float*) – The amount of time that should pass.
+  * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]*  *|* *None*) – A function without positional arguments that evaluates to a boolean.
+    The function is evaluated after every new frame has been rendered.
+    Playing the animation stops after the return value is truthy, or
+    after the specified `run_time` has passed.
+  * **frozen_frame** (*bool* *|* *None*) – Controls whether or not the wait animation is static, i.e., corresponds
+    to a frozen frame. If `False` is passed, the render loop still
+    progresses through the animation as usual and (among other things)
+    continues to call updater functions. If `None` (the default value),
+    the [`Scene.play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call tries to determine whether the Wait call
+    can be static or not itself via `Scene.should_mobjects_update()`.
+  * **kwargs** – Keyword arguments to be passed to the parent class, [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Wait.begin)                             | Begin the animation.                                                                                      |
+|------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Wait.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.animation.Wait.finish)                           | Finish the animation.                                                                                     |
+| [`interpolate`](#manim.animation.animation.Wait.interpolate)                 | Set the animation progress.                                                                               |
+| [`update_mobjects`](#manim.animation.animation.Wait.update_mobjects)         | Updates things like starting_mobject, and (for Transforms) target_mobject.                                |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(run_time=1, stop_condition=None, frozen_frame=None, rate_func=<function linear>, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **run_time** (*float*)
+  * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]*  *|* *None*)
+  * **frozen_frame** (*bool* *|* *None*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+  **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+  the end.
+* **Return type:**
+  None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject.  Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+  **dt** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.md

@@ -0,0 +1,96 @@
+# animation
+
+Animate mobjects.
+
+### Classes
+
+| [`Add`](manim.animation.animation.Add.md#manim.animation.animation.Add)                   | Add Mobjects to a scene, without animating them in any other way.   |
+|-------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+| [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) | An animation.                                                       |
+| [`Wait`](manim.animation.animation.Wait.md#manim.animation.animation.Wait)                | A "no operation" animation.                                         |
+
+### Functions
+
+### override_animation(animation_class)
+
+Decorator used to mark methods as overrides for specific [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) types.
+
+Should only be used to decorate methods of classes derived from [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+`Animation` overrides get inherited to subclasses of the `Mobject` who defined
+them. They don’t override subclasses of the `Animation` they override.
+
+#### SEE ALSO
+[`add_animation_override()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_animation_override)
+
+* **Parameters:**
+  **animation_class** (*type* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation to be overridden.
+* **Returns:**
+  The actual decorator. This marks the method as overriding an animation.
+* **Return type:**
+  Callable[[Callable], Callable]
+
+### Examples
+
+<div id="overrideanimationexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: OverrideAnimationExample <a class="headerlink" href="#overrideanimationexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./OverrideAnimationExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class MySquare(Square):
+    @override_animation(FadeIn)
+    def _fade_in_override(self, **kwargs):
+        return Create(self, **kwargs)
+
+class OverrideAnimationExample(Scene):
+    def construct(self):
+        self.play(FadeIn(MySquare()))
+```
+
+<pre data-manim-binder data-manim-classname="OverrideAnimationExample">
+class MySquare(Square):
+    @override_animation(FadeIn)
+    def \_fade_in_override(self, \*\*kwargs):
+        return Create(self, \*\*kwargs)
+
+class OverrideAnimationExample(Scene):
+    def construct(self):
+        self.play(FadeIn(MySquare()))
+
+</pre></div>
+
+### prepare_animation(anim)
+
+Returns either an unchanged animation, or the animation built
+from a passed animation factory.
+
+### Examples
+
+```default
+>>> from manim import Square, FadeIn
+>>> s = Square()
+>>> prepare_animation(FadeIn(s))
+FadeIn(Square)
+```
+
+```default
+>>> prepare_animation(s.animate.scale(2).rotate(42))
+_MethodAnimation(Square)
+```
+
+```default
+>>> prepare_animation(42)
+Traceback (most recent call last):
+...
+TypeError: Object 42 cannot be converted to an animation
+```
+
+* **Parameters:**
+  **anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|*  *\_AnimationBuilder*)
+* **Return type:**
+  [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)

data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.AnimatedBoundary.md

@@ -0,0 +1,66 @@
+# AnimatedBoundary
+
+Qualified name: `manim.animation.changing.AnimatedBoundary`
+
+### *class* AnimatedBoundary(vmobject, colors=[ManimColor('#29ABCA'), ManimColor('#9CDCEB'), ManimColor('#236B8E'), ManimColor('#736357')], max_stroke_width=3, cycle_rate=0.5, back_and_forth=True, draw_rate_func=<function smooth>, fade_rate_func=<function smooth>, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+Boundary of a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) with animated color change.
+
+### Examples
+
+<div id="animatedboundaryexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: AnimatedBoundaryExample <a class="headerlink" href="#animatedboundaryexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./AnimatedBoundaryExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class AnimatedBoundaryExample(Scene):
+    def construct(self):
+        text = Text("So shiny!")
+        boundary = AnimatedBoundary(text, colors=[RED, GREEN, BLUE],
+                                    cycle_rate=3)
+        self.add(text, boundary)
+        self.wait(2)
+```
+
+<pre data-manim-binder data-manim-classname="AnimatedBoundaryExample">
+class AnimatedBoundaryExample(Scene):
+    def construct(self):
+        text = Text("So shiny!")
+        boundary = AnimatedBoundary(text, colors=[RED, GREEN, BLUE],
+                                    cycle_rate=3)
+        self.add(text, boundary)
+        self.wait(2)
+
+</pre></div>
+
+### Methods
+
+| `full_family_become_partial`   |    |
+|--------------------------------|----|
+| `update_boundary_copies`       |    |
+
+### Attributes
+
+| `animate`             | Used to animate the application of any method of `self`.               |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` |                                                                        |
+| `color`               |                                                                        |
+| `depth`               | The depth of the mobject.                                              |
+| `fill_color`          | If there are multiple colors (for gradient) this returns the first one |
+| `height`              | The height of the mobject.                                             |
+| `n_points_per_curve`  |                                                                        |
+| `sheen_factor`        |                                                                        |
+| `stroke_color`        |                                                                        |
+| `width`               | The width of the mobject.                                              |
+
+#### \_original_\_init_\_(vmobject, colors=[ManimColor('#29ABCA'), ManimColor('#9CDCEB'), ManimColor('#236B8E'), ManimColor('#736357')], max_stroke_width=3, cycle_rate=0.5, back_and_forth=True, draw_rate_func=<function smooth>, fade_rate_func=<function smooth>, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.

data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.TracedPath.md

@@ -0,0 +1,113 @@
+# TracedPath
+
+Qualified name: `manim.animation.changing.TracedPath`
+
+### *class* TracedPath(traced_point_func, stroke_width=2, stroke_color=ManimColor('#FFFFFF'), dissipating_time=None, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Traces the path of a point returned by a function call.
+
+* **Parameters:**
+  * **traced_point_func** (*Callable*) – The function to be traced.
+  * **stroke_width** (*float*) – The width of the trace.
+  * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the trace.
+  * **dissipating_time** (*float* *|* *None*) – The time taken for the path to dissipate. Default set to `None`
+    which disables dissipation.
+
+### Examples
+
+<div id="tracedpathexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: TracedPathExample <a class="headerlink" href="#tracedpathexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./TracedPathExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class TracedPathExample(Scene):
+    def construct(self):
+        circ = Circle(color=RED).shift(4*LEFT)
+        dot = Dot(color=RED).move_to(circ.get_start())
+        rolling_circle = VGroup(circ, dot)
+        trace = TracedPath(circ.get_start)
+        rolling_circle.add_updater(lambda m: m.rotate(-0.3))
+        self.add(trace, rolling_circle)
+        self.play(rolling_circle.animate.shift(8*RIGHT), run_time=4, rate_func=linear)
+```
+
+<pre data-manim-binder data-manim-classname="TracedPathExample">
+class TracedPathExample(Scene):
+    def construct(self):
+        circ = Circle(color=RED).shift(4\*LEFT)
+        dot = Dot(color=RED).move_to(circ.get_start())
+        rolling_circle = VGroup(circ, dot)
+        trace = TracedPath(circ.get_start)
+        rolling_circle.add_updater(lambda m: m.rotate(-0.3))
+        self.add(trace, rolling_circle)
+        self.play(rolling_circle.animate.shift(8\*RIGHT), run_time=4, rate_func=linear)
+
+</pre></div><div id="dissipatingpathexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: DissipatingPathExample <a class="headerlink" href="#dissipatingpathexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./DissipatingPathExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class DissipatingPathExample(Scene):
+    def construct(self):
+        a = Dot(RIGHT * 2)
+        b = TracedPath(a.get_center, dissipating_time=0.5, stroke_opacity=[0, 1])
+        self.add(a, b)
+        self.play(a.animate(path_arc=PI / 4).shift(LEFT * 2))
+        self.play(a.animate(path_arc=-PI / 4).shift(LEFT * 2))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="DissipatingPathExample">
+class DissipatingPathExample(Scene):
+    def construct(self):
+        a = Dot(RIGHT \* 2)
+        b = TracedPath(a.get_center, dissipating_time=0.5, stroke_opacity=[0, 1])
+        self.add(a, b)
+        self.play(a.animate(path_arc=PI / 4).shift(LEFT \* 2))
+        self.play(a.animate(path_arc=-PI / 4).shift(LEFT \* 2))
+        self.wait()
+
+</pre></div>
+
+### Methods
+
+| `update_path`   |    |
+|-----------------|----|
+
+### Attributes
+
+| `animate`             | Used to animate the application of any method of `self`.               |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` |                                                                        |
+| `color`               |                                                                        |
+| `depth`               | The depth of the mobject.                                              |
+| `fill_color`          | If there are multiple colors (for gradient) this returns the first one |
+| `height`              | The height of the mobject.                                             |
+| `n_points_per_curve`  |                                                                        |
+| `sheen_factor`        |                                                                        |
+| `stroke_color`        |                                                                        |
+| `width`               | The width of the mobject.                                              |
+
+#### \_original_\_init_\_(traced_point_func, stroke_width=2, stroke_color=ManimColor('#FFFFFF'), dissipating_time=None, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **traced_point_func** (*Callable*)
+  * **stroke_width** (*float*)
+  * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+  * **dissipating_time** (*float* *|* *None*)

data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.md

@@ -0,0 +1,9 @@
+# changing
+
+Animation of a mobject boundary and tracing of points.
+
+### Classes
+
+| [`AnimatedBoundary`](manim.animation.changing.AnimatedBoundary.md#manim.animation.changing.AnimatedBoundary)   | Boundary of a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) with animated color change.   |
+|----------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`TracedPath`](manim.animation.changing.TracedPath.md#manim.animation.changing.TracedPath)                     | Traces the path of a point returned by a function call.                                                                                                      |

data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.AnimationGroup.md

@@ -0,0 +1,153 @@
+# AnimationGroup
+
+Qualified name: `manim.animation.composition.AnimationGroup`
+
+### *class* AnimationGroup(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Plays a group or series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* *Iterable* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*  *|* *types.GeneratorType* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+  * **group** ([*Group*](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *|* *OpenGLGroup* *|* *OpenGLVGroup*) – A group of multiple [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+  * **run_time** (*float* *|* *None*) – The duration of the animation in seconds.
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function defining the animation progress based on the relative
+    runtime (see [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)) .
+  * **lag_ratio** (*float*) – 
+
+    Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+    `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+    Defaults to 0.0, meaning that all animations will be played together.
+
+    This does not influence the total runtime of the animation. Instead the runtime
+    of individual animations is adjusted so that the complete animation has the defined
+    run time.
+
+### Methods
+
+| [`begin`](#manim.animation.composition.AnimationGroup.begin)                                                 | Begin the animation.                                                                                      |
+|--------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`build_animations_with_timings`](#manim.animation.composition.AnimationGroup.build_animations_with_timings) | Creates a list of triplets of the form (anim, start_time, end_time).                                      |
+| [`clean_up_from_scene`](#manim.animation.composition.AnimationGroup.clean_up_from_scene)                     | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.composition.AnimationGroup.finish)                                               | Finish the animation.                                                                                     |
+| [`get_all_mobjects`](#manim.animation.composition.AnimationGroup.get_all_mobjects)                           | Get all mobjects involved in the animation.                                                               |
+| [`init_run_time`](#manim.animation.composition.AnimationGroup.init_run_time)                                 | Calculates the run time of the animation, if different from `run_time`.                                   |
+| [`interpolate`](#manim.animation.composition.AnimationGroup.interpolate)                                     | Set the animation progress.                                                                               |
+| [`update_mobjects`](#manim.animation.composition.AnimationGroup.update_mobjects)                             | Updates things like starting_mobject, and (for Transforms) target_mobject.                                |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(\*animations, group=None, run_time=None, rate_func=<function linear>, lag_ratio=0, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* *Iterable* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*  *|* *types.GeneratorType* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*)
+  * **group** ([*Group*](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *|* *OpenGLGroup* *|* *OpenGLVGroup*)
+  * **run_time** (*float* *|* *None*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **lag_ratio** (*float*)
+* **Return type:**
+  None
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+  **scene** – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### build_animations_with_timings()
+
+Creates a list of triplets of the form (anim, start_time, end_time).
+
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+  The sequence of mobjects.
+* **Return type:**
+  Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### init_run_time(run_time)
+
+Calculates the run time of the animation, if different from `run_time`.
+
+* **Parameters:**
+  **run_time** – The duration of the animation in seconds.
+* **Returns:**
+  The duration of the animation in seconds.
+* **Return type:**
+  run_time
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+  **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+  the end.
+* **Return type:**
+  None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject.  Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+  **dt** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.LaggedStart.md

@@ -0,0 +1,100 @@
+# LaggedStart
+
+Qualified name: `manim.animation.composition.LaggedStart`
+
+### *class* LaggedStart(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Adjusts the timing of a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) according to `lag_ratio`.
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+  * **lag_ratio** (*float*) – 
+
+    Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+    `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+    Defaults to 0.05, meaning that the next animation will begin when 5% of the current
+    animation has played.
+
+    This does not influence the total runtime of the animation. Instead the runtime
+    of individual animations is adjusted so that the complete animation has the defined
+    run time.
+
+### Examples
+
+<div id="laggedstartexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaggedStartExample <a class="headerlink" href="#laggedstartexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./LaggedStartExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class LaggedStartExample(Scene):
+    def construct(self):
+        title = Text("lag_ratio = 0.25").to_edge(UP)
+
+        dot1 = Dot(point=LEFT * 2 + UP, radius=0.16)
+        dot2 = Dot(point=LEFT * 2, radius=0.16)
+        dot3 = Dot(point=LEFT * 2 + DOWN, radius=0.16)
+        line_25 = DashedLine(
+            start=LEFT + UP * 2,
+            end=LEFT + DOWN * 2,
+            color=RED
+        )
+        label = Text("25%", font_size=24).next_to(line_25, UP)
+        self.add(title, dot1, dot2, dot3, line_25, label)
+
+        self.play(LaggedStart(
+            dot1.animate.shift(RIGHT * 4),
+            dot2.animate.shift(RIGHT * 4),
+            dot3.animate.shift(RIGHT * 4),
+            lag_ratio=0.25,
+            run_time=4
+        ))
+```
+
+<pre data-manim-binder data-manim-classname="LaggedStartExample">
+class LaggedStartExample(Scene):
+    def construct(self):
+        title = Text("lag_ratio = 0.25").to_edge(UP)
+
+        dot1 = Dot(point=LEFT \* 2 + UP, radius=0.16)
+        dot2 = Dot(point=LEFT \* 2, radius=0.16)
+        dot3 = Dot(point=LEFT \* 2 + DOWN, radius=0.16)
+        line_25 = DashedLine(
+            start=LEFT + UP \* 2,
+            end=LEFT + DOWN \* 2,
+            color=RED
+        )
+        label = Text("25%", font_size=24).next_to(line_25, UP)
+        self.add(title, dot1, dot2, dot3, line_25, label)
+
+        self.play(LaggedStart(
+            dot1.animate.shift(RIGHT \* 4),
+            dot2.animate.shift(RIGHT \* 4),
+            dot3.animate.shift(RIGHT \* 4),
+            lag_ratio=0.25,
+            run_time=4
+        ))
+
+</pre></div>
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(\*animations, lag_ratio=0.05, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+  * **lag_ratio** (*float*)

data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.LaggedStartMap.md

@@ -0,0 +1,88 @@
+# LaggedStartMap
+
+Qualified name: `manim.animation.composition.LaggedStartMap`
+
+### *class* LaggedStartMap(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`LaggedStart`](manim.animation.composition.LaggedStart.md#manim.animation.composition.LaggedStart)
+
+Plays a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) while mapping a function to submobjects.
+
+* **Parameters:**
+  * **AnimationClass** (*Callable* *[* *...* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) to apply to mobject.
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) whose submobjects the animation, and optionally the function,
+    are to be applied.
+  * **arg_creator** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *str* *]*) – Function which will be applied to [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+  * **run_time** (*float*) – The duration of the animation in seconds.
+
+### Examples
+
+<div id="laggedstartmapexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: LaggedStartMapExample <a class="headerlink" href="#laggedstartmapexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./LaggedStartMapExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class LaggedStartMapExample(Scene):
+    def construct(self):
+        title = Tex("LaggedStartMap").to_edge(UP, buff=LARGE_BUFF)
+        dots = VGroup(
+            *[Dot(radius=0.16) for _ in range(35)]
+            ).arrange_in_grid(rows=5, cols=7, buff=MED_LARGE_BUFF)
+        self.add(dots, title)
+
+        # Animate yellow ripple effect
+        for mob in dots, title:
+            self.play(LaggedStartMap(
+                ApplyMethod, mob,
+                lambda m : (m.set_color, YELLOW),
+                lag_ratio = 0.1,
+                rate_func = there_and_back,
+                run_time = 2
+            ))
+```
+
+<pre data-manim-binder data-manim-classname="LaggedStartMapExample">
+class LaggedStartMapExample(Scene):
+    def construct(self):
+        title = Tex("LaggedStartMap").to_edge(UP, buff=LARGE_BUFF)
+        dots = VGroup(
+            \*[Dot(radius=0.16) for \_ in range(35)]
+            ).arrange_in_grid(rows=5, cols=7, buff=MED_LARGE_BUFF)
+        self.add(dots, title)
+
+        # Animate yellow ripple effect
+        for mob in dots, title:
+            self.play(LaggedStartMap(
+                ApplyMethod, mob,
+                lambda m : (m.set_color, YELLOW),
+                lag_ratio = 0.1,
+                rate_func = there_and_back,
+                run_time = 2
+            ))
+
+</pre></div>
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(AnimationClass, mobject, arg_creator=None, run_time=2, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **AnimationClass** (*Callable* *[* *[* *...* *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*)
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **arg_creator** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *str* *]*)
+  * **run_time** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.Succession.md

@@ -0,0 +1,160 @@
+# Succession
+
+Qualified name: `manim.animation.composition.Succession`
+
+### *class* Succession(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Plays a series of animations in succession.
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+  * **lag_ratio** (*float*) – 
+
+    Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+    `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+    Defaults to 1.0, meaning that the next animation will begin when 100% of the current
+    animation has played.
+
+    This does not influence the total runtime of the animation. Instead the runtime
+    of individual animations is adjusted so that the complete animation has the defined
+    run time.
+
+### Examples
+
+<div id="successionexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SuccessionExample <a class="headerlink" href="#successionexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./SuccessionExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class SuccessionExample(Scene):
+    def construct(self):
+        dot1 = Dot(point=LEFT * 2 + UP * 2, radius=0.16, color=BLUE)
+        dot2 = Dot(point=LEFT * 2 + DOWN * 2, radius=0.16, color=MAROON)
+        dot3 = Dot(point=RIGHT * 2 + DOWN * 2, radius=0.16, color=GREEN)
+        dot4 = Dot(point=RIGHT * 2 + UP * 2, radius=0.16, color=YELLOW)
+        self.add(dot1, dot2, dot3, dot4)
+
+        self.play(Succession(
+            dot1.animate.move_to(dot2),
+            dot2.animate.move_to(dot3),
+            dot3.animate.move_to(dot4),
+            dot4.animate.move_to(dot1)
+        ))
+```
+
+<pre data-manim-binder data-manim-classname="SuccessionExample">
+class SuccessionExample(Scene):
+    def construct(self):
+        dot1 = Dot(point=LEFT \* 2 + UP \* 2, radius=0.16, color=BLUE)
+        dot2 = Dot(point=LEFT \* 2 + DOWN \* 2, radius=0.16, color=MAROON)
+        dot3 = Dot(point=RIGHT \* 2 + DOWN \* 2, radius=0.16, color=GREEN)
+        dot4 = Dot(point=RIGHT \* 2 + UP \* 2, radius=0.16, color=YELLOW)
+        self.add(dot1, dot2, dot3, dot4)
+
+        self.play(Succession(
+            dot1.animate.move_to(dot2),
+            dot2.animate.move_to(dot3),
+            dot3.animate.move_to(dot4),
+            dot4.animate.move_to(dot1)
+        ))
+
+</pre></div>
+
+### Methods
+
+| [`begin`](#manim.animation.composition.Succession.begin)                     | Begin the animation.                                                       |
+|------------------------------------------------------------------------------|----------------------------------------------------------------------------|
+| [`finish`](#manim.animation.composition.Succession.finish)                   | Finish the animation.                                                      |
+| [`interpolate`](#manim.animation.composition.Succession.interpolate)         | Set the animation progress.                                                |
+| [`next_animation`](#manim.animation.composition.Succession.next_animation)   | Proceeds to the next animation.                                            |
+| `update_active_animation`                                                    |                                                                            |
+| [`update_mobjects`](#manim.animation.composition.Succession.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(\*animations, lag_ratio=1, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+  * **lag_ratio** (*float*)
+* **Return type:**
+  None
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+  **scene** – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+  **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+  the end.
+* **Return type:**
+  None
+
+#### next_animation()
+
+Proceeds to the next animation.
+
+This method is called right when the active animation finishes.
+
+* **Return type:**
+  None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject.  Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+  **dt** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.md

@@ -0,0 +1,11 @@
+# composition
+
+Tools for displaying multiple animations at once.
+
+### Classes
+
+| [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)   | Plays a group or series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation).                                 |
+|----------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`LaggedStart`](manim.animation.composition.LaggedStart.md#manim.animation.composition.LaggedStart)            | Adjusts the timing of a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) according to `lag_ratio`. |
+| [`LaggedStartMap`](manim.animation.composition.LaggedStartMap.md#manim.animation.composition.LaggedStartMap)   | Plays a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) while mapping a function to submobjects.  |
+| [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession)               | Plays a series of animations in succession.                                                                                                           |

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextLetterByLetter.md

@@ -0,0 +1,39 @@
+# AddTextLetterByLetter
+
+Qualified name: `manim.animation.creation.AddTextLetterByLetter`
+
+### *class* AddTextLetterByLetter(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ShowIncreasingSubsets`](manim.animation.creation.ShowIncreasingSubsets.md#manim.animation.creation.ShowIncreasingSubsets)
+
+Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter on the scene.
+
+* **Parameters:**
+  * **time_per_char** (*float*) – Frequency of appearance of the letters.
+  * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **run_time** (*float* *|* *None*)
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(text, suspend_mobject_updating=False, int_func=<ufunc 'ceil'>, rate_func=<function linear>, time_per_char=0.1, run_time=None, reverse_rate_function=False, introducer=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **time_per_char** (*float*)
+  * **run_time** (*float* *|* *None*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextWordByWord.md

@@ -0,0 +1,31 @@
+# AddTextWordByWord
+
+Qualified name: `manim.animation.creation.AddTextWordByWord`
+
+### *class* AddTextWordByWord(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession)
+
+Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) word by word on the scene. Note: currently broken.
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **text_mobject** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **run_time** (*float*)
+  * **time_per_char** (*float*)
+
+#### \_original_\_init_\_(text_mobject, run_time=None, time_per_char=0.06, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **text_mobject** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **run_time** (*float*)
+  * **time_per_char** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Create.md

@@ -0,0 +1,62 @@
+# Create
+
+Qualified name: `manim.animation.creation.Create`
+
+### *class* Create(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ShowPartial`](manim.animation.creation.ShowPartial.md#manim.animation.creation.ShowPartial)
+
+Incrementally show a VMobject.
+
+* **Parameters:**
+  * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject* *|* *OpenGLSurface*) – The VMobject to animate.
+  * **lag_ratio** (*float*)
+  * **introducer** (*bool*)
+* **Raises:**
+  **TypeError** – If `mobject` is not an instance of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Examples
+
+<div id="createscene" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: CreateScene <a class="headerlink" href="#createscene">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./CreateScene-1.mp4">
+</video>
+```python
+from manim import *
+
+class CreateScene(Scene):
+    def construct(self):
+        self.play(Create(Square()))
+```
+
+<pre data-manim-binder data-manim-classname="CreateScene">
+class CreateScene(Scene):
+    def construct(self):
+        self.play(Create(Square()))
+
+</pre></div>
+
+#### SEE ALSO
+[`ShowPassingFlash`](manim.animation.indication.ShowPassingFlash.md#manim.animation.indication.ShowPassingFlash)
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, lag_ratio=1.0, introducer=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject* *|* *OpenGLSurface*)
+  * **lag_ratio** (*float*)
+  * **introducer** (*bool*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.DrawBorderThenFill.md

@@ -0,0 +1,95 @@
+# DrawBorderThenFill
+
+Qualified name: `manim.animation.creation.DrawBorderThenFill`
+
+### *class* DrawBorderThenFill(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Draw the border first and then show the fill.
+
+### Examples
+
+<div id="showdrawborderthenfill" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ShowDrawBorderThenFill <a class="headerlink" href="#showdrawborderthenfill">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ShowDrawBorderThenFill-1.mp4">
+</video>
+```python
+from manim import *
+
+class ShowDrawBorderThenFill(Scene):
+    def construct(self):
+        self.play(DrawBorderThenFill(Square(fill_opacity=1, fill_color=ORANGE)))
+```
+
+<pre data-manim-binder data-manim-classname="ShowDrawBorderThenFill">
+class ShowDrawBorderThenFill(Scene):
+    def construct(self):
+        self.play(DrawBorderThenFill(Square(fill_opacity=1, fill_color=ORANGE)))
+
+</pre></div>
+
+### Methods
+
+| [`begin`](#manim.animation.creation.DrawBorderThenFill.begin)                       | Begin the animation.                        |
+|-------------------------------------------------------------------------------------|---------------------------------------------|
+| [`get_all_mobjects`](#manim.animation.creation.DrawBorderThenFill.get_all_mobjects) | Get all mobjects involved in the animation. |
+| `get_outline`                                                                       |                                             |
+| `get_stroke_color`                                                                  |                                             |
+| `interpolate_submobject`                                                            |                                             |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **run_time** (*float*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **stroke_width** (*float*)
+  * **stroke_color** (*str*)
+  * **draw_border_animation_config** (*dict*)
+  * **fill_animation_config** (*dict*)
+  * **introducer** (*bool*)
+
+#### \_original_\_init_\_(vmobject, run_time=2, rate_func=<function double_smooth>, stroke_width=2, stroke_color=None, draw_border_animation_config={}, fill_animation_config={}, introducer=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **run_time** (*float*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **stroke_width** (*float*)
+  * **stroke_color** (*str*)
+  * **draw_border_animation_config** (*dict*)
+  * **fill_animation_config** (*dict*)
+  * **introducer** (*bool*)
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+  The sequence of mobjects.
+* **Return type:**
+  Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.RemoveTextLetterByLetter.md

@@ -0,0 +1,39 @@
+# RemoveTextLetterByLetter
+
+Qualified name: `manim.animation.creation.RemoveTextLetterByLetter`
+
+### *class* RemoveTextLetterByLetter(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter)
+
+Remove a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter from the scene.
+
+* **Parameters:**
+  * **time_per_char** (*float*) – Frequency of appearance of the letters.
+  * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **run_time** (*float* *|* *None*)
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(text, suspend_mobject_updating=False, int_func=<ufunc 'ceil'>, rate_func=<function linear>, time_per_char=0.1, run_time=None, reverse_rate_function=True, introducer=False, remover=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **time_per_char** (*float*)
+  * **run_time** (*float* *|* *None*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.ShowIncreasingSubsets.md

@@ -0,0 +1,77 @@
+# ShowIncreasingSubsets
+
+Qualified name: `manim.animation.creation.ShowIncreasingSubsets`
+
+### *class* ShowIncreasingSubsets(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Show one submobject at a time, leaving all previous ones displayed on screen.
+
+### Examples
+
+<div id="showincreasingsubsetsscene" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ShowIncreasingSubsetsScene <a class="headerlink" href="#showincreasingsubsetsscene">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ShowIncreasingSubsetsScene-1.mp4">
+</video>
+```python
+from manim import *
+
+class ShowIncreasingSubsetsScene(Scene):
+    def construct(self):
+        p = VGroup(Dot(), Square(), Triangle())
+        self.add(p)
+        self.play(ShowIncreasingSubsets(p))
+        self.wait()
+```
+
+<pre data-manim-binder data-manim-classname="ShowIncreasingSubsetsScene">
+class ShowIncreasingSubsetsScene(Scene):
+    def construct(self):
+        p = VGroup(Dot(), Square(), Triangle())
+        self.add(p)
+        self.play(ShowIncreasingSubsets(p))
+        self.wait()
+
+</pre></div>
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.creation.ShowIncreasingSubsets.interpolate_mobject)   | Interpolates the mobject of the `Animation` based on alpha value.   |
+|------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+| `update_submobject_list`                                                                       |                                                                     |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **group** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+
+#### \_original_\_init_\_(group, suspend_mobject_updating=False, int_func=<ufunc 'floor'>, reverse_rate_function=False, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **group** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **suspend_mobject_updating** (*bool*)
+  * **int_func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*)
+* **Return type:**
+  None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+  **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+  is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+  to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.ShowPartial.md

@@ -0,0 +1,34 @@
+# ShowPartial
+
+Qualified name: `manim.animation.creation.ShowPartial`
+
+### *class* ShowPartial(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Abstract class for Animations that show the VMobject partially.
+
+* **Raises:**
+  **TypeError** – If `mobject` is not an instance of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+* **Parameters:**
+  **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject* *|* *OpenGLSurface* *|* *None*)
+
+#### SEE ALSO
+[`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create), [`ShowPassingFlash`](manim.animation.indication.ShowPassingFlash.md#manim.animation.indication.ShowPassingFlash)
+
+### Methods
+
+| `interpolate_submobject`   |    |
+|----------------------------|----|
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject* *|* *OpenGLSurface* *|* *None*)

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.ShowSubmobjectsOneByOne.md

@@ -0,0 +1,32 @@
+# ShowSubmobjectsOneByOne
+
+Qualified name: `manim.animation.creation.ShowSubmobjectsOneByOne`
+
+### *class* ShowSubmobjectsOneByOne(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ShowIncreasingSubsets`](manim.animation.creation.ShowIncreasingSubsets.md#manim.animation.creation.ShowIncreasingSubsets)
+
+Show one submobject at a time, removing all previously displayed ones from screen.
+
+### Methods
+
+| `update_submobject_list`   |    |
+|----------------------------|----|
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **group** (*Iterable* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+  * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+
+#### \_original_\_init_\_(group, int_func=<ufunc 'ceil'>, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **group** (*Iterable* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+  * **int_func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.SpiralIn.md

@@ -0,0 +1,80 @@
+# SpiralIn
+
+Qualified name: `manim.animation.creation.SpiralIn`
+
+### *class* SpiralIn(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Create the Mobject with sub-Mobjects flying in on spiral trajectories.
+
+* **Parameters:**
+  * **shapes** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobject on which to be operated.
+  * **scale_factor** (*float*) – The factor used for scaling the effect.
+  * **fade_in_fraction** – Fractional duration of initial fade-in of sub-Mobjects as they fly inward.
+
+### Examples
+
+<div id="spiralinexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: SpiralInExample <a class="headerlink" href="#spiralinexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./SpiralInExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class SpiralInExample(Scene):
+    def construct(self):
+        pi = MathTex(r"\pi").scale(7)
+        pi.shift(2.25 * LEFT + 1.5 * UP)
+        circle = Circle(color=GREEN_C, fill_opacity=1).shift(LEFT)
+        square = Square(color=BLUE_D, fill_opacity=1).shift(UP)
+        shapes = VGroup(pi, circle, square)
+        self.play(SpiralIn(shapes))
+```
+
+<pre data-manim-binder data-manim-classname="SpiralInExample">
+class SpiralInExample(Scene):
+    def construct(self):
+        pi = MathTex(r"\\pi").scale(7)
+        pi.shift(2.25 \* LEFT + 1.5 \* UP)
+        circle = Circle(color=GREEN_C, fill_opacity=1).shift(LEFT)
+        square = Square(color=BLUE_D, fill_opacity=1).shift(UP)
+        shapes = VGroup(pi, circle, square)
+        self.play(SpiralIn(shapes))
+
+</pre></div>
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.creation.SpiralIn.interpolate_mobject)   | Interpolates the mobject of the `Animation` based on alpha value.   |
+|-----------------------------------------------------------------------------------|---------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(shapes, scale_factor=8, fade_in_fraction=0.3, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **shapes** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **scale_factor** (*float*)
+* **Return type:**
+  None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+  **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+  is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+  to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.TypeWithCursor.md

@@ -0,0 +1,126 @@
+# TypeWithCursor
+
+Qualified name: `manim.animation.creation.TypeWithCursor`
+
+### *class* TypeWithCursor(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter)
+
+Similar to [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter) , but with an additional cursor mobject at the end.
+
+* **Parameters:**
+  * **time_per_char** (*float*) – Frequency of appearance of the letters.
+  * **cursor** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) shown after the last added letter.
+  * **buff** (*float*) – Controls how far away the cursor is to the right of the last added letter.
+  * **keep_cursor_y** (*bool*) – If `True`, the cursor’s y-coordinate is set to the center of the `Text` and remains the same throughout the animation. Otherwise, it is set to the center of the last added letter.
+  * **leave_cursor_on** (*bool*) – Whether to show the cursor after the animation.
+  * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex.
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+
+### Examples
+
+<div id="insertingtextexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: InsertingTextExample <a class="headerlink" href="#insertingtextexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./InsertingTextExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class InsertingTextExample(Scene):
+    def construct(self):
+        text = Text("Inserting", color=PURPLE).scale(1.5).to_edge(LEFT)
+        cursor = Rectangle(
+            color = GREY_A,
+            fill_color = GREY_A,
+            fill_opacity = 1.0,
+            height = 1.1,
+            width = 0.5,
+        ).move_to(text[0]) # Position the cursor
+
+        self.play(TypeWithCursor(text, cursor))
+        self.play(Blink(cursor, blinks=2))
+```
+
+<pre data-manim-binder data-manim-classname="InsertingTextExample">
+class InsertingTextExample(Scene):
+    def construct(self):
+        text = Text("Inserting", color=PURPLE).scale(1.5).to_edge(LEFT)
+        cursor = Rectangle(
+            color = GREY_A,
+            fill_color = GREY_A,
+            fill_opacity = 1.0,
+            height = 1.1,
+            width = 0.5,
+        ).move_to(text[0]) # Position the cursor
+
+        self.play(TypeWithCursor(text, cursor))
+        self.play(Blink(cursor, blinks=2))
+
+</pre>
+
+References: [`Blink`](manim.animation.indication.Blink.md#manim.animation.indication.Blink)
+
+</div>
+
+### Methods
+
+| [`begin`](#manim.animation.creation.TypeWithCursor.begin)                             | Begin the animation.                                                                                      |
+|---------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.creation.TypeWithCursor.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.creation.TypeWithCursor.finish)                           | Finish the animation.                                                                                     |
+| `update_submobject_list`                                                              |                                                                                                           |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(text, cursor, buff=0.1, keep_cursor_y=True, leave_cursor_on=True, time_per_char=0.1, reverse_rate_function=False, introducer=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **cursor** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **buff** (*float*)
+  * **keep_cursor_y** (*bool*)
+  * **leave_cursor_on** (*bool*)
+  * **time_per_char** (*float*)
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Uncreate.md

@@ -0,0 +1,59 @@
+# Uncreate
+
+Qualified name: `manim.animation.creation.Uncreate`
+
+### *class* Uncreate(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+
+Like [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create) but in reverse.
+
+### Examples
+
+<div id="showuncreate" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ShowUncreate <a class="headerlink" href="#showuncreate">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ShowUncreate-1.mp4">
+</video>
+```python
+from manim import *
+
+class ShowUncreate(Scene):
+    def construct(self):
+        self.play(Uncreate(Square()))
+```
+
+<pre data-manim-binder data-manim-classname="ShowUncreate">
+class ShowUncreate(Scene):
+    def construct(self):
+        self.play(Uncreate(Square()))
+
+</pre></div>
+
+#### SEE ALSO
+[`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **reverse_rate_function** (*bool*)
+  * **remover** (*bool*)
+
+#### \_original_\_init_\_(mobject, reverse_rate_function=True, remover=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **reverse_rate_function** (*bool*)
+  * **remover** (*bool*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.UntypeWithCursor.md

@@ -0,0 +1,85 @@
+# UntypeWithCursor
+
+Qualified name: `manim.animation.creation.UntypeWithCursor`
+
+### *class* UntypeWithCursor(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`TypeWithCursor`](manim.animation.creation.TypeWithCursor.md#manim.animation.creation.TypeWithCursor)
+
+Similar to [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) , but with an additional cursor mobject at the end.
+
+* **Parameters:**
+  * **time_per_char** (*float*) – Frequency of appearance of the letters.
+  * **cursor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) shown after the last added letter.
+  * **buff** – Controls how far away the cursor is to the right of the last added letter.
+  * **keep_cursor_y** – If `True`, the cursor’s y-coordinate is set to the center of the `Text` and remains the same throughout the animation. Otherwise, it is set to the center of the last added letter.
+  * **leave_cursor_on** – Whether to show the cursor after the animation.
+  * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex.
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+
+### Examples
+
+<div id="deletingtextexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: DeletingTextExample <a class="headerlink" href="#deletingtextexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./DeletingTextExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class DeletingTextExample(Scene):
+    def construct(self):
+        text = Text("Deleting", color=PURPLE).scale(1.5).to_edge(LEFT)
+        cursor = Rectangle(
+            color = GREY_A,
+            fill_color = GREY_A,
+            fill_opacity = 1.0,
+            height = 1.1,
+            width = 0.5,
+        ).move_to(text[0]) # Position the cursor
+
+        self.play(UntypeWithCursor(text, cursor))
+        self.play(Blink(cursor, blinks=2))
+```
+
+<pre data-manim-binder data-manim-classname="DeletingTextExample">
+class DeletingTextExample(Scene):
+    def construct(self):
+        text = Text("Deleting", color=PURPLE).scale(1.5).to_edge(LEFT)
+        cursor = Rectangle(
+            color = GREY_A,
+            fill_color = GREY_A,
+            fill_opacity = 1.0,
+            height = 1.1,
+            width = 0.5,
+        ).move_to(text[0]) # Position the cursor
+
+        self.play(UntypeWithCursor(text, cursor))
+        self.play(Blink(cursor, blinks=2))
+
+</pre>
+
+References: [`Blink`](manim.animation.indication.Blink.md#manim.animation.indication.Blink)
+
+</div>
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(text, cursor=None, time_per_char=0.1, reverse_rate_function=True, introducer=False, remover=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+  * **cursor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*)
+  * **time_per_char** (*float*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Unwrite.md

@@ -0,0 +1,86 @@
+# Unwrite
+
+Qualified name: `manim.animation.creation.Unwrite`
+
+### *class* Unwrite(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Write`](manim.animation.creation.Write.md#manim.animation.creation.Write)
+
+Simulate erasing by hand a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+* **Parameters:**
+  * **reverse** (*bool*) – Set True to have the animation start erasing from the last submobject first.
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+
+### Examples
+
+<div id="unwritereversetrue" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: UnwriteReverseTrue <a class="headerlink" href="#unwritereversetrue">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./UnwriteReverseTrue-1.mp4">
+</video>
+```python
+from manim import *
+
+class UnwriteReverseTrue(Scene):
+    def construct(self):
+        text = Tex("Alice and Bob").scale(3)
+        self.add(text)
+        self.play(Unwrite(text))
+```
+
+<pre data-manim-binder data-manim-classname="UnwriteReverseTrue">
+class UnwriteReverseTrue(Scene):
+    def construct(self):
+        text = Tex("Alice and Bob").scale(3)
+        self.add(text)
+        self.play(Unwrite(text))
+
+</pre></div><div id="unwritereversefalse" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: UnwriteReverseFalse <a class="headerlink" href="#unwritereversefalse">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./UnwriteReverseFalse-1.mp4">
+</video>
+```python
+from manim import *
+
+class UnwriteReverseFalse(Scene):
+    def construct(self):
+        text = Tex("Alice and Bob").scale(3)
+        self.add(text)
+        self.play(Unwrite(text, reverse=False))
+```
+
+<pre data-manim-binder data-manim-classname="UnwriteReverseFalse">
+class UnwriteReverseFalse(Scene):
+    def construct(self):
+        text = Tex("Alice and Bob").scale(3)
+        self.add(text)
+        self.play(Unwrite(text, reverse=False))
+
+</pre></div>
+
+### Methods
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+
+#### \_original_\_init_\_(vmobject, rate_func=<function linear>, reverse=True, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **reverse** (*bool*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Write.md

@@ -0,0 +1,112 @@
+# Write
+
+Qualified name: `manim.animation.creation.Write`
+
+### *class* Write(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`DrawBorderThenFill`](manim.animation.creation.DrawBorderThenFill.md#manim.animation.creation.DrawBorderThenFill)
+
+Simulate hand-writing a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or hand-drawing a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Examples
+
+<div id="showwrite" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ShowWrite <a class="headerlink" href="#showwrite">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ShowWrite-1.mp4">
+</video>
+```python
+from manim import *
+
+class ShowWrite(Scene):
+    def construct(self):
+        self.play(Write(Text("Hello", font_size=144)))
+```
+
+<pre data-manim-binder data-manim-classname="ShowWrite">
+class ShowWrite(Scene):
+    def construct(self):
+        self.play(Write(Text("Hello", font_size=144)))
+
+</pre></div><div id="showwritereversed" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: ShowWriteReversed <a class="headerlink" href="#showwritereversed">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./ShowWriteReversed-1.mp4">
+</video>
+```python
+from manim import *
+
+class ShowWriteReversed(Scene):
+    def construct(self):
+        self.play(Write(Text("Hello", font_size=144), reverse=True, remover=False))
+```
+
+<pre data-manim-binder data-manim-classname="ShowWriteReversed">
+class ShowWriteReversed(Scene):
+    def construct(self):
+        self.play(Write(Text("Hello", font_size=144), reverse=True, remover=False))
+
+</pre></div>
+
+### Tests
+
+Check that creating empty [`Write`](#manim.animation.creation.Write) animations works:
+
+```default
+>>> from manim import Write, Text
+>>> Write(Text(''))
+Write(Text(''))
+```
+
+### Methods
+
+| [`begin`](#manim.animation.creation.Write.begin)   | Begin the animation.   |
+|----------------------------------------------------|------------------------|
+| [`finish`](#manim.animation.creation.Write.finish) | Finish the animation.  |
+| `reverse_submobjects`                              |                        |
+
+### Attributes
+
+| `run_time`   |    |
+|--------------|----|
+* **Parameters:**
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **reverse** (*bool*)
+
+#### \_original_\_init_\_(vmobject, rate_func=<function linear>, reverse=False, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+  * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+  * **reverse** (*bool*)
+* **Return type:**
+  None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+  None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.md

@@ -0,0 +1,29 @@
+# creation
+
+Animate the display or removal of a mobject from a scene.
+
+<video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./CreationModule-1.mp4">
+</video>
+
+### Classes
+
+| [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter)          | Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter on the scene.                                                                                                                       |
+|--------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`AddTextWordByWord`](manim.animation.creation.AddTextWordByWord.md#manim.animation.creation.AddTextWordByWord)                      | Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) word by word on the scene.                                                                                                                           |
+| [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)                                                       | Incrementally show a VMobject.                                                                                                                                                                                                                     |
+| [`DrawBorderThenFill`](manim.animation.creation.DrawBorderThenFill.md#manim.animation.creation.DrawBorderThenFill)                   | Draw the border first and then show the fill.                                                                                                                                                                                                      |
+| [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) | Remove a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter from the scene.                                                                                                                   |
+| [`ShowIncreasingSubsets`](manim.animation.creation.ShowIncreasingSubsets.md#manim.animation.creation.ShowIncreasingSubsets)          | Show one submobject at a time, leaving all previous ones displayed on screen.                                                                                                                                                                      |
+| [`ShowPartial`](manim.animation.creation.ShowPartial.md#manim.animation.creation.ShowPartial)                                        | Abstract class for Animations that show the VMobject partially.                                                                                                                                                                                    |
+| [`ShowSubmobjectsOneByOne`](manim.animation.creation.ShowSubmobjectsOneByOne.md#manim.animation.creation.ShowSubmobjectsOneByOne)    | Show one submobject at a time, removing all previously displayed ones from screen.                                                                                                                                                                 |
+| [`SpiralIn`](manim.animation.creation.SpiralIn.md#manim.animation.creation.SpiralIn)                                                 | Create the Mobject with sub-Mobjects flying in on spiral trajectories.                                                                                                                                                                             |
+| [`TypeWithCursor`](manim.animation.creation.TypeWithCursor.md#manim.animation.creation.TypeWithCursor)                               | Similar to [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter) , but with an additional cursor mobject at the end.                                                         |
+| [`Uncreate`](manim.animation.creation.Uncreate.md#manim.animation.creation.Uncreate)                                                 | Like [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create) but in reverse.                                                                                                                                                |
+| [`UntypeWithCursor`](manim.animation.creation.UntypeWithCursor.md#manim.animation.creation.UntypeWithCursor)                         | Similar to [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) , but with an additional cursor mobject at the end.                                                |
+| [`Unwrite`](manim.animation.creation.Unwrite.md#manim.animation.creation.Unwrite)                                                    | Simulate erasing by hand a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).           |
+| [`Write`](manim.animation.creation.Write.md#manim.animation.creation.Write)                                                          | Simulate hand-writing a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or hand-drawing a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). |

data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeIn.md

@@ -0,0 +1,86 @@
+# FadeIn
+
+Qualified name: `manim.animation.fading.FadeIn`
+
+### *class* FadeIn(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `_Fade`
+
+Fade in [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.
+
+* **Parameters:**
+  * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be faded in.
+  * **shift** – The vector by which the mobject shifts while being faded in.
+  * **target_position** – The position from which the mobject starts while being faded in. In case
+    another mobject is given as target position, its center is used.
+  * **scale** – The factor by which the mobject is scaled initially before being rescaling to
+    its original size while being faded in.
+
+### Examples
+
+<div id="fadeinexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: FadeInExample <a class="headerlink" href="#fadeinexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./FadeInExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class FadeInExample(Scene):
+    def construct(self):
+        dot = Dot(UP * 2 + LEFT)
+        self.add(dot)
+        tex = Tex(
+            "FadeIn with ", "shift ", r" or target\_position", " and scale"
+        ).scale(1)
+        animations = [
+            FadeIn(tex[0]),
+            FadeIn(tex[1], shift=DOWN),
+            FadeIn(tex[2], target_position=dot),
+            FadeIn(tex[3], scale=1.5),
+        ]
+        self.play(AnimationGroup(*animations, lag_ratio=0.5))
+```
+
+<pre data-manim-binder data-manim-classname="FadeInExample">
+class FadeInExample(Scene):
+    def construct(self):
+        dot = Dot(UP \* 2 + LEFT)
+        self.add(dot)
+        tex = Tex(
+            "FadeIn with ", "shift ", r" or target\\_position", " and scale"
+        ).scale(1)
+        animations = [
+            FadeIn(tex[0]),
+            FadeIn(tex[1], shift=DOWN),
+            FadeIn(tex[2], target_position=dot),
+            FadeIn(tex[3], scale=1.5),
+        ]
+        self.play(AnimationGroup(\*animations, lag_ratio=0.5))
+
+</pre></div>
+
+### Methods
+
+| `create_starting_mobject`   |    |
+|-----------------------------|----|
+| `create_target`             |    |
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(\*mobjects, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeOut.md

@@ -0,0 +1,97 @@
+# FadeOut
+
+Qualified name: `manim.animation.fading.FadeOut`
+
+### *class* FadeOut(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `_Fade`
+
+Fade out [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.
+
+* **Parameters:**
+  * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be faded out.
+  * **shift** – The vector by which the mobject shifts while being faded out.
+  * **target_position** – The position to which the mobject moves while being faded out. In case another
+    mobject is given as target position, its center is used.
+  * **scale** – The factor by which the mobject is scaled while being faded out.
+
+### Examples
+
+<div id="fadeinexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: FadeInExample <a class="headerlink" href="#fadeinexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./FadeInExample-2.mp4">
+</video>
+```python
+from manim import *
+
+class FadeInExample(Scene):
+    def construct(self):
+        dot = Dot(UP * 2 + LEFT)
+        self.add(dot)
+        tex = Tex(
+            "FadeOut with ", "shift ", r" or target\_position", " and scale"
+        ).scale(1)
+        animations = [
+            FadeOut(tex[0]),
+            FadeOut(tex[1], shift=DOWN),
+            FadeOut(tex[2], target_position=dot),
+            FadeOut(tex[3], scale=0.5),
+        ]
+        self.play(AnimationGroup(*animations, lag_ratio=0.5))
+```
+
+<pre data-manim-binder data-manim-classname="FadeInExample">
+class FadeInExample(Scene):
+    def construct(self):
+        dot = Dot(UP \* 2 + LEFT)
+        self.add(dot)
+        tex = Tex(
+            "FadeOut with ", "shift ", r" or target\\_position", " and scale"
+        ).scale(1)
+        animations = [
+            FadeOut(tex[0]),
+            FadeOut(tex[1], shift=DOWN),
+            FadeOut(tex[2], target_position=dot),
+            FadeOut(tex[3], scale=0.5),
+        ]
+        self.play(AnimationGroup(\*animations, lag_ratio=0.5))
+
+</pre></div>
+
+### Methods
+
+| [`clean_up_from_scene`](#manim.animation.fading.FadeOut.clean_up_from_scene)   | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.   |
+|--------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+| `create_target`                                                                |                                                                                                             |
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(\*mobjects, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+  None
+
+#### clean_up_from_scene(scene=None)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+  **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.md

@@ -0,0 +1,40 @@
+# fading
+
+Fading in and out of view.
+
+<div id="fading" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: Fading <a class="headerlink" href="#fading">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./Fading-1.mp4">
+</video>
+```python
+from manim import *
+
+class Fading(Scene):
+    def construct(self):
+        tex_in = Tex("Fade", "In").scale(3)
+        tex_out = Tex("Fade", "Out").scale(3)
+        self.play(FadeIn(tex_in, shift=DOWN, scale=0.66))
+        self.play(ReplacementTransform(tex_in, tex_out))
+        self.play(FadeOut(tex_out, shift=DOWN * 2, scale=1.5))
+```
+
+<pre data-manim-binder data-manim-classname="Fading">
+class Fading(Scene):
+    def construct(self):
+        tex_in = Tex("Fade", "In").scale(3)
+        tex_out = Tex("Fade", "Out").scale(3)
+        self.play(FadeIn(tex_in, shift=DOWN, scale=0.66))
+        self.play(ReplacementTransform(tex_in, tex_out))
+        self.play(FadeOut(tex_out, shift=DOWN \* 2, scale=1.5))
+
+</pre></div>
+
+### Classes
+
+| [`FadeIn`](manim.animation.fading.FadeIn.md#manim.animation.fading.FadeIn)    | Fade in [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.   |
+|-------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| [`FadeOut`](manim.animation.fading.FadeOut.md#manim.animation.fading.FadeOut) | Fade out [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.  |

data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowArrow.md

@@ -0,0 +1,66 @@
+# GrowArrow
+
+Qualified name: `manim.animation.growing.GrowArrow`
+
+### *class* GrowArrow(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`GrowFromPoint`](manim.animation.growing.GrowFromPoint.md#manim.animation.growing.GrowFromPoint)
+
+Introduce an [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) by growing it from its start toward its tip.
+
+* **Parameters:**
+  * **arrow** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)) – The arrow to be introduced.
+  * **point_color** (*str*) – Initial color of the arrow before growing to its full size. Leave empty to match arrow’s color.
+
+### Examples
+
+<div id="growarrowexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GrowArrowExample <a class="headerlink" href="#growarrowexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./GrowArrowExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class GrowArrowExample(Scene):
+    def construct(self):
+        arrows = [Arrow(2 * LEFT, 2 * RIGHT), Arrow(2 * DR, 2 * UL)]
+        VGroup(*arrows).set_x(0).arrange(buff=2)
+        self.play(GrowArrow(arrows[0]))
+        self.play(GrowArrow(arrows[1], point_color=RED))
+```
+
+<pre data-manim-binder data-manim-classname="GrowArrowExample">
+class GrowArrowExample(Scene):
+    def construct(self):
+        arrows = [Arrow(2 \* LEFT, 2 \* RIGHT), Arrow(2 \* DR, 2 \* UL)]
+        VGroup(\*arrows).set_x(0).arrange(buff=2)
+        self.play(GrowArrow(arrows[0]))
+        self.play(GrowArrow(arrows[1], point_color=RED))
+
+</pre></div>
+
+### Methods
+
+| `create_starting_mobject`   |    |
+|-----------------------------|----|
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(arrow, point_color=None, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **arrow** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow))
+  * **point_color** (*str*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowFromCenter.md

@@ -0,0 +1,63 @@
+# GrowFromCenter
+
+Qualified name: `manim.animation.growing.GrowFromCenter`
+
+### *class* GrowFromCenter(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`GrowFromPoint`](manim.animation.growing.GrowFromPoint.md#manim.animation.growing.GrowFromPoint)
+
+Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from its center.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be introduced.
+  * **point_color** (*str*) – Initial color of the mobject before growing to its full size. Leave empty to match mobject’s color.
+
+### Examples
+
+<div id="growfromcenterexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GrowFromCenterExample <a class="headerlink" href="#growfromcenterexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./GrowFromCenterExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class GrowFromCenterExample(Scene):
+    def construct(self):
+        squares = [Square() for _ in range(2)]
+        VGroup(*squares).set_x(0).arrange(buff=2)
+        self.play(GrowFromCenter(squares[0]))
+        self.play(GrowFromCenter(squares[1], point_color=RED))
+```
+
+<pre data-manim-binder data-manim-classname="GrowFromCenterExample">
+class GrowFromCenterExample(Scene):
+    def construct(self):
+        squares = [Square() for \_ in range(2)]
+        VGroup(\*squares).set_x(0).arrange(buff=2)
+        self.play(GrowFromCenter(squares[0]))
+        self.play(GrowFromCenter(squares[1], point_color=RED))
+
+</pre></div>
+
+### Methods
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(mobject, point_color=None, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **point_color** (*str*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowFromEdge.md

@@ -0,0 +1,69 @@
+# GrowFromEdge
+
+Qualified name: `manim.animation.growing.GrowFromEdge`
+
+### *class* GrowFromEdge(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`GrowFromPoint`](manim.animation.growing.GrowFromPoint.md#manim.animation.growing.GrowFromPoint)
+
+Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from one of its bounding box edges.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be introduced.
+  * **edge** (*np.ndarray*) – The direction to seek bounding box edge of mobject.
+  * **point_color** (*str*) – Initial color of the mobject before growing to its full size. Leave empty to match mobject’s color.
+
+### Examples
+
+<div id="growfromedgeexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GrowFromEdgeExample <a class="headerlink" href="#growfromedgeexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./GrowFromEdgeExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class GrowFromEdgeExample(Scene):
+    def construct(self):
+        squares = [Square() for _ in range(4)]
+        VGroup(*squares).set_x(0).arrange(buff=1)
+        self.play(GrowFromEdge(squares[0], DOWN))
+        self.play(GrowFromEdge(squares[1], RIGHT))
+        self.play(GrowFromEdge(squares[2], UR))
+        self.play(GrowFromEdge(squares[3], UP, point_color=RED))
+```
+
+<pre data-manim-binder data-manim-classname="GrowFromEdgeExample">
+class GrowFromEdgeExample(Scene):
+    def construct(self):
+        squares = [Square() for \_ in range(4)]
+        VGroup(\*squares).set_x(0).arrange(buff=1)
+        self.play(GrowFromEdge(squares[0], DOWN))
+        self.play(GrowFromEdge(squares[1], RIGHT))
+        self.play(GrowFromEdge(squares[2], UR))
+        self.play(GrowFromEdge(squares[3], UP, point_color=RED))
+
+</pre></div>
+
+### Methods
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(mobject, edge, point_color=None, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **edge** (*np.ndarray*)
+  * **point_color** (*str*)
+* **Return type:**
+  None

data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowFromPoint.md

@@ -0,0 +1,77 @@
+# GrowFromPoint
+
+Qualified name: `manim.animation.growing.GrowFromPoint`
+
+### *class* GrowFromPoint(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from a point.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be introduced.
+  * **point** (*np.ndarray*) – The point from which the mobject grows.
+  * **point_color** (*str*) – Initial color of the mobject before growing to its full size. Leave empty to match mobject’s color.
+
+### Examples
+
+<div id="growfrompointexample" class="admonition admonition-manim-example">
+<p class="admonition-title">Example: GrowFromPointExample <a class="headerlink" href="#growfrompointexample">¶</a></p><video
+    class="manim-video"
+    controls
+    loop
+    autoplay
+    src="./GrowFromPointExample-1.mp4">
+</video>
+```python
+from manim import *
+
+class GrowFromPointExample(Scene):
+    def construct(self):
+        dot = Dot(3 * UR, color=GREEN)
+        squares = [Square() for _ in range(4)]
+        VGroup(*squares).set_x(0).arrange(buff=1)
+        self.add(dot)
+        self.play(GrowFromPoint(squares[0], ORIGIN))
+        self.play(GrowFromPoint(squares[1], [-2, 2, 0]))
+        self.play(GrowFromPoint(squares[2], [3, -2, 0], RED))
+        self.play(GrowFromPoint(squares[3], dot, dot.get_color()))
+```
+
+<pre data-manim-binder data-manim-classname="GrowFromPointExample">
+class GrowFromPointExample(Scene):
+    def construct(self):
+        dot = Dot(3 \* UR, color=GREEN)
+        squares = [Square() for \_ in range(4)]
+        VGroup(\*squares).set_x(0).arrange(buff=1)
+        self.add(dot)
+        self.play(GrowFromPoint(squares[0], ORIGIN))
+        self.play(GrowFromPoint(squares[1], [-2, 2, 0]))
+        self.play(GrowFromPoint(squares[2], [3, -2, 0], RED))
+        self.play(GrowFromPoint(squares[3], dot, dot.get_color()))
+
+</pre></div>
+
+### Methods
+
+| `create_starting_mobject`   |    |
+|-----------------------------|----|
+| `create_target`             |    |
+
+### Attributes
+
+| `path_arc`   |    |
+|--------------|----|
+| `path_func`  |    |
+| `run_time`   |    |
+
+#### \_original_\_init_\_(mobject, point, point_color=None, \*\*kwargs)
+
+Initialize self.  See help(type(self)) for accurate signature.
+
+* **Parameters:**
+  * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+  * **point** (*np.ndarray*)
+  * **point_color** (*str*)
+* **Return type:**
+  None