diff --git a/posts/_metadata.json b/posts/_metadata.json
index 06fa24e..1e4d0b4 100644
--- a/posts/_metadata.json
+++ b/posts/_metadata.json
@@ -268,5 +268,14 @@
     "author": "jet/Prussia",
     "tags": ["code", "project", "web", "build", "docs", "typescript_javascript"],
     "archived": false
+  },
+  "pilanimate": {
+    "title": "PilAnimate Docs",
+    "slug": "pilanimate",
+    "filename": "pilanimate",
+    "date": "Either 2022 or 2021?",
+    "author": "jet/Prussia",
+    "tags": ["code", "project", "animation", "images"],
+    "archived": true 
   }
 }
diff --git a/posts/pilanimate.md b/posts/pilanimate.md
new file mode 100644
index 0000000..aa936d6
--- /dev/null
+++ b/posts/pilanimate.md
@@ -0,0 +1,488 @@
+PilAnimate is a python library that renders video frame by frame, using PIL.
+
+Documentations are up to date for version 0.4.1. A lot of the library is just a wrapper for PIL, so if you are having trouble it could be useful to reference those if you encounter any issues.
+
+## Why use PilAnimate?
+
+I mostly made PilAnimate for my personal use, and I'm sure there's probably better ones out there, but I made PilAnimate to be fairly simple and easily extendable. It renders frame by frame, meaning that even the most complex tasks can be completed on old computers, albeit slowly.
+
+## Install
+
+```
+pip install pilanimate
+```
+
+## Animation
+
+**Class**
+
+Creates layers
+
+Parameters:
+
+- layer_num: number of layers
+- size (optional=(1600,900)): size in pixels [width,height]
+- fps (optional=25): frames per second
+- mode (optional="RGBA"): Type and depth of a pixel in the image. See PIL docs.
+- color (optional=0): background color to use for the image
+
+Returns: itself
+
+Properties: layers, fps, mode, size
+
+### export
+
+**Function**
+
+Turns frames into video.
+
+Parameters:
+
+- filename (optional="hey"): The name of the output file
+
+Returns: Nothing, creates filename+".avi" video
+
+## Layer
+
+**Class**
+
+Creates layer. A layer is essentially an array of images. When the video is exporting, the layers will be pasted on each other to create an array of frames (layer 0 is at the bottom).
+
+> Warning: Do not create this class yourself, making the Animation class will do it for you.
+
+Parameters:
+
+- size: size in pixels [width,height]
+- fps: frames per second
+- mode (optional="RGBA"): Type and depth of a pixel in the image
+- color (optional=0): background color to use for the image
+
+Returns: itself
+
+Properties: size, img, layer, fps, frames, mode
+
+### createPoint
+
+**Function**
+
+Creates a point at coords
+
+Parameters:
+
+- coords: Coordinates of the point [x,y]
+- fill (optional=None): Color of pixel
+
+Returns: nothing
+
+### createLine
+
+**Function**
+
+Creates line, where each array [x,y] inside coords is a point, connected in order.
+
+Parameters:
+
+- coords: Coordinates of line [[x,y],[x,y],[x,y]...]
+- fill (optional=None): Color of line
+- width (optional=0): Width of line
+- joint (optional=None): if 'curve', joint type between the points is curved
+
+Returns: nothing
+
+### createArc
+
+**Function**
+
+Creates arc with starting and ending angles inside the bounding box.
+
+Parameters:
+
+- boundingBox: array consisting of upper left and lower right corners [[x,y],[x,y]]
+- startAngle: angle in degreees
+- endAngle: angle in degrees
+- fill (optional=None): color of arc
+- width (optional=0): width of arc line
+
+Returns: nothing
+
+### createEllipse
+
+**Function**
+
+Creates ellipse inside bounding box
+
+Parameters:
+
+- boundingBox: array consisting of upper left and lower right corners [[x,y],[x,y]]
+- fill (optional=None): color of ellipse inside
+- outline (optional=None): outline color
+- width (optional=0): pixel width of outline
+
+Returns: nothing
+
+### createPolygon
+
+**Function**
+
+Creates polygon
+
+Parameters:
+
+- coords: List of points of the polygon outline [[x,y],[x,y],[x,y]...]
+- fill (optional=None): color of polygon inside
+- outline (optional=None): outline color
+
+Returns: nothing
+
+### createRectangle
+
+**Function**
+
+Creates rectangle
+
+Parameters:
+
+- boundingBox: array consisting of upper left and lower right corners [[x,y],[x,y]]
+- fill (optional=None): color of rectangle inside
+- outline (optional=None): outline color
+- width (optional=1): width of outline
+
+Returns: nothing
+
+### createRoundedRectangle
+
+**Function**
+
+Creates a rounded rectangle
+
+Parameters:
+
+- boundingBox: array consisting of upper left and lower right corners [[x,y],[x,y]]
+- radius (optional=0): radius of the rounded corners of the rectangle
+- fill (optional=None): color of rectangle inside
+- outline (optional=None): outline color
+- width (optional=0): width of outline
+
+Returns: nothing
+
+### fillAll
+
+**Function**
+
+Fills entire layer with color
+
+Parameters:
+
+- fill (optional=None): fill of frame
+- outline (optional=None): outline color of frame
+- width (optional=0): outline line width
+
+Returns: nothing
+
+### createText
+
+**Function**
+
+Creates text at coords to layer. Has a kinds of parameters that can be fiddled with, making it a really powerful function.
+
+Parameters:
+
+- anchorCoords: Anchor coordinates of the text
+- text: The text to be added
+- fill (optional=None): Fill color of text
+- font (optional=None): A Pil ImageFont
+- anchor (optional=None): Relative location of anchor to the text.
+- spacing (optional=4): Number of pixels between the lines of text
+- align (optional='left'): Alignment of lines (center, left, or right)
+- direction (optional=None): Direction of text. See PIL docs for more information.
+- features (optional=None): OpenType font features. See PIL docs for more information.
+- language (optional=None): Language of text. See PIL docs for more information.
+- stroke_width (optional=0): Width of stroke
+- stroke_fill (optional=None): Fill color of the stroke
+- embedded_color (optional=False): True/False to specify if font embedded color glyphs should be used or not
+
+Returns: nothing
+
+### addImage
+
+**Function**
+
+Adds image to layer
+
+Parameters:
+
+- imageToAdd: PIL Image
+- coords (optional=None): Coords to put image. Array that is upper left and lower right corner. ((x,y), (x,y))
+
+Returns: nothing
+
+### addGif
+
+**Function**
+
+Adds a gif to the layer (this function also creates frames for you, for the number of frames long the gif is * times_to_repeat frames)
+
+Parameters:
+
+- gif_location: location of the gif in the file system
+- times_to_repeat: times to repeat the gif
+- coords (optional=None): Coords to put image. Array that is upper left and lower right corner. ((x,y), (x,y))
+
+Returns: nothing, but appends frames
+
+### rotate
+
+**Function**
+
+Rotates layer
+
+Parameters:
+
+- angle: degrees
+- center (optional=None): Center of rotation,
+- outsideFillColor (optional=None):
+- copy (optional=None): a PIL Image. Probably want this to be a copy of the current layer.
+
+Returns: nothing
+
+### translate
+
+**Function**
+
+Move layer
+
+Parameters:
+
+- x: amount of pixels to move horizontally
+- y: amount of pixels to move vertically
+- img: copy of current layer
+
+Returns: nothing
+
+### changeOpacity
+
+**Function**
+
+Changes opacity (transparency) of the layer, of every non transparent pixel.
+
+Parameters:
+
+- value: new opacity from 0 to 100, where 0 is invisible and 100 is opaque (fully non transparent)
+
+Returns: nothing
+
+### changeEntireOpacity
+
+**Function**
+
+Changes opacity of entire layer, including transparent pixels, so only use this for layers with no transparent parts
+
+Parameters:
+
+- value: new opacity from 0 to 100, where 0 is invisible and 100 is opaque (fully non transparent)
+
+Returns: nothing
+
+### fadeIn
+
+**Function**
+
+Slowly fades in a layer, going from transparent to fully opaque.
+
+Parameters:
+
+- frames: number of frames it should take to become fully opaque
+
+Returns: nothing, but appends frames
+
+### fadeOut
+
+**Function**
+
+Slowly fades out a layer, going from fully opaque to fully transparent.
+
+Parameters:
+
+- frames: number of frames it should take to become fully transparent
+
+Returns: nothing, but appends frames
+
+### transform
+
+**Function**
+
+Transforms layer. This function is very complicated so and frankly I have no clue what most of thse are, so please refer to PIL Docs for more detail.
+
+Parameters:
+
+- size: output size
+- method: transformation method, so please refer to PIL Docs
+- data (optional=None): According to PIL docs, 'extra data to the transformation method.'
+- resample (optional=0): Resampling filter, please refer to PIL Docs
+- fill (optional=1): Please refer to PIL Docs
+- fillcolor (optional=None): Fill color for area outside transformed image
+
+Returns: nothing
+
+### blur
+
+**Function**
+
+Blurs layer
+
+Parameters: none
+
+Returns: nothing
+
+### clear
+
+**Function**
+
+Clears area of layer, turning it transparent
+
+Parameters:
+
+- coords: Array that is upper left and lower right corner of the area that should be cleared. ((x,y), (x,y))
+
+### clearAll
+
+**Function**
+
+Clears entire layer, turning it transparent
+
+Parameters: none
+
+Returns: nothing
+
+### saveFrame
+
+**Function**
+
+Adds the layer in its current state to the frames array
+
+Parameters: none
+
+Returns: nothing, but appends a frame
+
+### doNothing
+
+**Function**
+
+Adds frames without changing the layer
+
+Parameters:
+
+- frames: number of frames to append
+
+Returns: nothing
+
+### save
+
+**Function**
+
+Save current layer as a file
+
+Parameters:
+
+- filename: file name of current layer
+
+Returns: nothing
+
+### rise
+
+**Function**
+
+Make layer slowly rise
+
+Parameters:
+
+- frames: number of frames the rising should last
+- total_rise_amount: amount of pixels it should move up by
+
+Returns: nothing, but appends frames
+
+### descend
+
+**Function**
+
+Make layer slowly descend
+
+Parameters:
+
+- frames: number of frames the descending should last
+- total_descend_amount: amount of pixels it should down up by
+
+Returns: nothing, but appends frames
+
+### slide
+
+**Function**
+
+Makes the layer slide to the side
+
+Parameters:
+
+- frames: number of frames the sliding should last
+- total_slide_amount: amount of pixels it should go to the side
+
+Returns: nothing, but appends frames
+
+### spin
+
+**Function**
+
+Makes the layer spin
+
+Parameters:
+
+- frames: number of frames the spinning should last
+- degrees: amount of degrees to spin
+- center: center where the rest of the image should spin around (x,y) coordinates
+
+Returns: nothing, but appends frames
+
+## Example
+
+Here's a basic example that creates a sun rising from the sea:
+
+```
+from PilAnimate import Animation, ImageColor, Image
+animation = Animation(3)
+animation.layers[0].fillAll(fill="SkyBlue")
+#sun layer
+animation.layers[1].createEllipse(((700,650),(900,850)), fill="yellow")
+#ocean layer
+animation.layers[2].createRectangle(((0, 500),(1600,900)), fill="Blue", width=0)
+animation.layers[0].doNothing(100)
+animation.layers[2].doNothing(100)
+animation.layers[1].rise(100, -501)
+animation.export()
+```
+
+## Extend
+
+Example of an extension I made that makes backgrounds:
+
+```
+from PilAnimate import Layer
+import math
+class Background():
+  #remember to add params
+  def __init__(self, layer, background_image):
+    self.background_image = background_image
+    self.layer = layer
+    self.layer.addImage(self.background_image.copy().crop((0,0,self.layer.size[0],self.layer.size[1])), coords=(0, 0, self.layer.size[0], self.layer.size[1]))
+  def pan_down(self, frames, all_the_way=True):
+    #speed is pixels per frame
+    #(background_image height-layer height)/speed
+    #
+    amount = (self.background_image.size[1]-self.layer.size[1])/frames
+    amount = math.floor(amount)
+    for i in range(frames-1):
+      self.layer.addImage(self.background_image.copy().crop((0, i*amount, self.background_image.size[0], i*amount+self.layer.size[1])), coords=(0, 0, self.layer.size[0], self.layer.size[1]))
+      self.layer.saveFrame()
+    if all_the_way:
+      self.layer.addImage(self.background_image.copy().crop((0, (self.background_image.size[1]-self.layer.size[1]), self.background_image.size[0], (self.background_image.size[1]-self.layer.size[1])+self.layer.size[1])), coords=(0, 0, self.layer.size[0], self.layer.size[1]))
+      self.layer.saveFrame()
+```
+