## No backing pixmap
```python
#!/usr/bin/env python3
import random

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
import sys

class MyWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)

        self.w, self.h = 680, 480
        self.setFixedSize(self.w,self.h)

        self.painter = QPainter()
        self.pen = QPen()
        self.penColor = QColor(0,0,0)
        self.brushColor = QColor(0,0,0)
        self.brush = QBrush()
        self.pen.setCapStyle(Qt.RoundCap)
        self.pen.setJoinStyle(Qt.RoundJoin)
        self.pen.setWidth(10)
        self.brush.setColor(self.brushColor)
        self.pen.setColor(self.penColor)

        self.setMouseTracking(True)

    def paintEvent(self, event: QPaintEvent):
        with QPainter(self) as painter:
          self.drawRandomRect(painter)


    def mouseMoveEvent(self, event: QMouseEvent):
        QWidget.mouseMoveEvent(self, event)

    def mousePressEvent(self, event: QMouseEvent):
        self.update()

    def drawRandomRect(self,painter):
        x0 = random.randrange(0,self.w-100)
        x1 = random.randrange(x0+10,self.w)
        y0 = random.randrange(0,self.h-100)
        y1 = random.randrange(y0+10,self.h)
        pw = random.randrange(1,20)

        r,g,b,a = [random.randrange(0,256) for i in range(4)]
        self.penColor = QColor(r,g,b)
        r,g,b,a = [random.randrange(0,256) for i in range(4)]
        self.brushColor = QColor(r,g,b,a)

        self.pen.setWidth(pw)
        self.brush.setColor(self.brushColor)
        self.pen.setColor(self.penColor)

        painter.setRenderHints(QPainter.Antialiasing, True)
        painter.fillRect(QRect(QPoint(x0,y0),QPoint(x1,y1)),self.brushColor)

    def mouseReleaseEvent(self, event: QMouseEvent):
        QWidget.mouseReleaseEvent(self, event)


class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)

        self.widget = MyWidget()
        self.setCentralWidget(self.widget)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    w = MainWindow()
    w.show()
    sys.exit(app.exec())
```
## Using a backing pixmap
```python
#!/usr/bin/env python3
import random

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
import sys

class MyWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)

        self.w, self.h = 680, 480
        self.setFixedSize(self.w,self.h)
        self.pixmap = QPixmap(self.size())
        self.pixmap.fill(Qt.white)

        self.painter = QPainter()
        self.pen = QPen()
        self.penColor = QColor(0,0,0)
        self.brushColor = QColor(0,0,0)
        self.brush = QBrush()
        self.pen.setCapStyle(Qt.RoundCap)
        self.pen.setJoinStyle(Qt.RoundJoin)
        self.pen.setWidth(10)
        self.brush.setColor(self.brushColor)
        self.pen.setColor(self.penColor)

    def paintEvent(self, event: QPaintEvent):
        with QPainter(self) as painter:
            painter.drawPixmap(0, 0, self.pixmap)

    def mousePressEvent(self, event: QMouseEvent):
        self.drawRandomRect()

    def drawRandomRect(self):
        x0 = random.randrange(0,self.w-100)
        x1 = random.randrange(x0+10,self.w)
        y0 = random.randrange(0,self.h-100)
        y1 = random.randrange(y0+10,self.h)
        pw = random.randrange(1,20)

        r,g,b,a = [random.randrange(0,256) for i in range(4)]
        self.penColor = QColor(r,g,b)
        r,g,b,a = [random.randrange(0,256) for i in range(4)]
        self.brushColor = QColor(r,g,b,a)

        self.pen.setWidth(pw)
        self.brush.setColor(self.brushColor)
        self.pen.setColor(self.penColor)

        self.painter.begin(self.pixmap)
        self.painter.setRenderHints(QPainter.Antialiasing, True)
        self.painter.fillRect(QRect(QPoint(x0,y0),QPoint(x1,y1)),self.brushColor)
        self.painter.end()
        self.update()

class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)

        self.widget = MyWidget()
        self.setCentralWidget(self.widget)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    w = MainWindow()
    w.show()
    sys.exit(app.exec())
```
## Simple Animation
```python
import random

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
import sys
from math import sin
import time

# rotate and translate example
class Spinner:
  def __init__(self,x,y,r,t0,fill=Qt.white,stroke=Qt.black,pw=1):
    self.x = x
    self.y = y
    self.r = r
    self.t0 = t0
    self.fill = fill
    self.stroke = stroke
    self.pw = pw
  def paint(self,painter):
    t = time.time()
    theta = 360*t/self.t0
    painter.save()
    painter.setBrush(self.fill)
    pen = QPen(self.stroke)
    pen.setCosmetic(True)
    pen.setWidth(self.pw)
    painter.setPen(pen)
    painter.translate(self.x,self.y)
    painter.rotate(theta)
    painter.scale(self.r,self.r)
    path = QPainterPath()
    path.moveTo(-1,-1)
    path.lineTo(1,-1)
    path.lineTo(1,1)
    path.lineTo(-1,1)
    path.closeSubpath()
    painter.drawPath(path)
    painter.restore()

class MyWidget(QWidget):
  def __init__(self, parent=None):
    super().__init__(parent)

    self.w, self.h = 680, 480
    self.setFixedSize(self.w,self.h)

    self.painter = QPainter()
    self.pen = QPen()
    self.penColor = QColor(0,255,0)
    self.brushColor = QColor(255,0,0)
    self.brush = QBrush()
    self.pen.setCapStyle(Qt.RoundCap)
    self.pen.setJoinStyle(Qt.RoundJoin)
    self.pen.setWidth(2)
    self.brush.setColor(self.brushColor)
    self.pen.setColor(self.penColor)
    self.pen.setCosmetic(True)
    self.spinners = [ 
      Spinner(200,200,100,1,Qt.cyan,Qt.green,8),
      Spinner(200,300,80,2,Qt.yellow,QColor(45,78,145)),
      Spinner(200,100,70,3) ,
      Spinner(400,240,50,4) ,
      Spinner(300,120,30,5) 
    ]

    fps = 30
    timer = QTimer(self)
    timer.timeout.connect(self.update)
    timer.setInterval(1000 // fps)
    timer.start()

  def paintEvent(self, event: QPaintEvent):
    with QPainter(self) as painter:
      painter.setBrush(self.brush)
      painter.setPen(self.pen)
      for spinner in self.spinners:
      spinner.paint(painter)


  def mouseMoveEvent(self, event: QMouseEvent):
    QWidget.mouseMoveEvent(self, event)

  def mousePressEvent(self, event: QMouseEvent):
    self.update()

  def mouseReleaseEvent(self, event: QMouseEvent):
    """Override method from QWidget"""
    QWidget.mouseReleaseEvent(self, event)

class MainWindow(QMainWindow):
  def __init__(self, parent=None):
    QMainWindow.__init__(self, parent)

    self.widget = MyWidget()
    self.setCentralWidget(self.widget)

if __name__ == "__main__":
  app = QApplication(sys.argv)

  w = MainWindow()
  w.show()
  sys.exit(app.exec())
```
## Simpler Animation
```python
from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
import sys
from math import sin,cos,pi
import time

# rotate and translate example
class Rotor:
  def __init__(self,x,y,r0,r1,t0,fill=Qt.white,stroke=Qt.black,pw=1):
    self.x = x
    self.y = y
    self.r0 = r0
    self.r1 = r1
    self.t0 = t0
    self.fill = fill
    self.stroke = stroke
    self.pw = pw
  def paint(self,painter):
    t = time.time()
    theta = 2*pi*t/self.t0
    x0 = self.x
    y0 = self.y
    r = self.r0
    x = x0 + r*sin(theta)
    y = y0 + r*cos(theta)
        
    painter.save()
    painter.setBrush(self.fill)
    pen = QPen(self.stroke)
    pen.setCosmetic(True)
    pen.setWidth(self.pw)
    painter.setPen(pen)
    path = QPainterPath()
    path.addEllipse(x,y,self.r1,self.r1)
    painter.drawPath(path)
    painter.restore()

class MyWidget(QWidget):
  def __init__(self, parent=None):
    super().__init__(parent)

    self.w, self.h = 680, 480
    self.setFixedSize(self.w,self.h)

    self.painter = QPainter()
    self.rotor = Rotor(self.w/2,self.h/2,0.4*min(self.w,self.h),20,1,Qt.red,Qt.black,3)

    fps = 60
    timer = QTimer(self)
    timer.timeout.connect(self.update)
    timer.setInterval(1000 // fps)
    timer.start()

  def paintEvent(self, event: QPaintEvent):
    with QPainter(self) as painter:
      self.rotor.paint(painter)

class MainWindow(QMainWindow):
  def __init__(self, parent=None):
    QMainWindow.__init__(self, parent)

    self.widget = MyWidget()
    self.setCentralWidget(self.widget)

if __name__ == "__main__":
  app = QApplication(sys.argv)

  w = MainWindow()
  w.show()
  sys.exit(app.exec())

```