Simulating paintbrush strokes in TikZ

Question

I am wondering if there exists a way to simulate paintbrush strokes in TikZ when filling in a shape. So given the following:

\documentclass{article}
\usepackage{tikz}
\begin{document}
\begin{tikzpicture}
\tikz{
\draw[fill=red](0,0)rectangle(10,10);
}
\end{tikzpicture}
\end{document}

Instead of a solid red shape I was hoping to make it look like the red part was painted on with a paintbrush. I'm not exactly sure how what that would look like but I'm guessing maybe some randomly wavy lines that are a little darker and some maybe that are a little lighter? And I guess one would want for the paintbrush to have a thickness so that you'd be able to see the difference between one stroke and the one next to it.

Looking at examples of actual paintbrush strokes online it looks like the light/dark parts vary a little on each line but that might be a complication not worth pursuing.

Having all the strokes go down would be fine but being able to indicate a directions would be cool.

And while I'm sure something like this is possible in various image editing programs, I need to do this in TeX/LaTeX as part of an automated file generating process.

Edit: I do not believe this is a duplicate of the chalkboard solution as that one appears to use a bunch of small dots whereas a paintbrush involves long wavy lines of varying shades of the root color. The results would look very different. It could be that the chalkboard question provides an idea for an approach but using it as-is would not be a solution to my question.

Update 1: I have done some experimentation with using TikZ decorations with wavy, random lines with rounded corners and it seems like this could be a way forward but I haven't made anything that looks close to convincing.

Update 2: As per below, here is a link to a picture of close-up of brush strokes. This is pretty exaggerated but gets the point across. Here is an attempt at using wavy random lines:

\documentclass{article}
\usepackage{tikz}
\usetikzlibrary{decorations.pathmorphing}
\begin{document}
\begin{tikzpicture}
\tikz[line width=.1mm]{
\draw[fill=red](0,0)rectangle(10,10);
\draw[line width = .5mm,decorate,decoration={random steps,segment length=12pt,amplitude=1pt},rounded corners=.1pt, color=red!50!brown] (1.5,0) -- (1.5,10);
\draw[line width = .5mm,decorate,decoration={random steps,segment length=12pt,amplitude=1pt},rounded corners=.1pt, color=red!50!brown] (1.65,0) -- (1.65,10);
\draw[line width = .5mm,decorate,decoration={random steps,segment length=12pt,amplitude=1pt},rounded corners=.1pt, color=red!50!brown] (1.8,0) -- (1.8,10);
\draw[line width = .5mm,decorate,decoration={random steps,segment length=12pt,amplitude=1pt},rounded corners=.1pt, color=red!50!brown] (1.95,0) -- (1.95,10);
}
\end{tikzpicture}
\end{document}

As you can see it looks terrible.

Update 3: Let me give a bit more detail about what I'm looking for. I am looking for something to fill large geometric shapes like squares, rectangles, and circles with sizes from half a page to almost a full page with one color. I have a program that generates music in many different styles (I'm a composer) but have decided to add artwork to it as well. So far I'm sticking with 20th century Modernist stuff as a lot of it seems simpler to do. I did a Mondrian one already (the squares and rectangles on thick crossing lines). And what inspired this question was the works of Kazimir Malevich, specifically his Black Square, Black Cross, Red Square and a few others of a similar style. My software randomly generates "paintings" that look similar but not exactly the same (for example, the black square varies in size but is still large, the red square uses different random dimensions for the quadrilateral, the black circle has different random dimensions and placed at random, etc). I had thought that since these are so simple that my users would appreciate having it be a bit more interesting to look at with the simulated brush strokes. Unfortunately I don't have any specific examples of paintings/painters in mind, just some vague notion that brush marks could be seen on paintings like those if you look closely enough(though I have no idea if you can see the brush strokes in Malevich's paintings). But then making it too subtle might get lost on the user when looking at it on their computer or phone so being a bit exaggerated might be better? It also occurs to me that maybe the bumps of the canvas underneath might help with the illusion?

Answer 1

This is a quickly written proposal based on this answer, which makes use of this answer. I plan to improve it later. (I am really not sure if understand the efforts to close the question. The chalk board post is IMHO related, but this question is IMHO not a duplicate thereof.)

\documentclass[tikz,border=3.14mm]{standalone}
\usetikzlibrary{decorations,arrows.meta,bending}
\begin{document}
\pgfdeclarearrow{
  name=ink,
  parameters= {\the\pgfarrowlength},  
  setup code={
   \pgfarrowssettipend{0pt}
   \pgfarrowssetlineend{-\pgfarrowlength}
   \pgfarrowlinewidth=\pgflinewidth
   \pgfarrowssavethe\pgfarrowlength
  },
  drawing code={
   \pgfpathmoveto{\pgfpoint{-\pgfarrowlength}{0.5\pgflinewidth}}
   \pgfpathcurveto{\pgfpoint{-0.75\pgfarrowlength}{0.6\pgflinewidth}}{%
   \pgfpoint{-0.01\pgfarrowlength}{0.6\pgflinewidth}}{%
   \pgfpoint{0pt}{0pt}}
   \pgfpathcurveto{\pgfpoint{-0.01\pgfarrowlength}{-0.5\pgflinewidth}}{%
   \pgfpoint{-0.2\pgfarrowlength}{-(1+0.3*rnd)*\pgflinewidth}}{%
   \pgfpoint{-0.3\pgfarrowlength}{-0.8*(1+0.3*rnd)*\pgflinewidth}}
   \pgfpathcurveto{\pgfpoint{-0.4\pgfarrowlength}{-0.6*(1+0.3*rnd)*\pgflinewidth}}{%
   \pgfpoint{-0.6\pgfarrowlength}{-0.3*(1+0.3*rnd)*\pgflinewidth}}{%
   \pgfpoint{-1\pgfarrowlength}{-0.5\pgflinewidth}}
   \pgfusepathqfill
  },
  defaults = { length = 12pt }
}
\pgfkeys{/pgf/decoration/.cd,
         start color/.store in=\startcolor,
         start color=black,
         end color/.store in=\endcolor,
         end color=black,
         varying line width steps/.initial=100
}
\pgfdeclaredecoration{width and color change}{initial}{
 \state{initial}[width=0pt, next state=line, persistent precomputation={%
   \pgfmathparse{\pgfdecoratedpathlength/\pgfkeysvalueof{/pgf/decoration/varying line width steps}}%
   \let\increment=\pgfmathresult%
   \def\x{0}%
 }]{}
 \state{line}[width=\increment pt,   persistent postcomputation={%
   \pgfmathsetmacro{\x}{\x+\increment}
   },next state=line]{%
   \pgfmathparse{ifthenelse(\x<\pgfdecoratedpathlength-5mm,varyinglw(100*(\x/\pgfdecoratedpathlength)),
    varyinglw(100*((\pgfdecoratedpathlength-5mm)/\pgfdecoratedpathlength))*(\pgfdecoratedpathlength-\x)/14) )}
   \pgfmathparse{varyinglw(100*(\x/\pgfdecoratedpathlength))} %<-changed
   \pgfsetlinewidth{\pgfmathresult pt}%
   \pgfpathmoveto{\pgfpointorigin}%
   \pgfmathsetmacro{\steplength}{1.4*\increment}
   \pgfpathlineto{\pgfqpoint{\steplength pt}{0pt}}%
   \pgfmathsetmacro{\y}{100*(\x/\pgfdecoratedpathlength)}
   \pgfsetstrokecolor{\endcolor!\y!\startcolor}%
   \pgfusepath{stroke}%
 }
 \state{final}{%
   \pgfsetlinewidth{\pgflinewidth}%
   \pgfpathmoveto{\pgfpointorigin}%
   \pgfmathsetmacro{\y}{100*(\x/\pgfdecoratedpathlength)}
   \color{\endcolor!\y!\startcolor}%
   \pgfusepath{stroke}% 
 }
}


\begin{tikzpicture}[varying arrow/.style={-{ink[length=5mm,width=3.2mm]},color=\endcolor,
postaction={/utils/exec=\pgfsetarrows{-},decorate,decoration={width and color change}}
}]
\begin{scope}[declare function={varyinglw(\x)=12+5*rnd;}]
\foreach \X in {0,...,5}
{\draw[%/pgf/decoration/start color=red,/pgf/decoration/end color=red,
decorate,decoration={width and color change,start color=red,end color=red}] 
(0,-\X*0.7-0.1+0.2*rnd) to[bend left=10-20*rnd] ++ (3,0);}
\end{scope}

\end{tikzpicture}
\end{document} 

UPDATE: Something that goes a little bit into the direction of the picture under the link that you added in your update. Takes rather long to compile and is far from satisfying. I am posting this merely as a report on where I went, hoping that others may find some of this useful.

\documentclass[tikz,border=3.14mm]{standalone}
\usetikzlibrary{decorations,decorations.pathreplacing,calc,positioning}
\begin{document}

\pgfkeys{/brush pars/.cd,
lines/.initial=16,
color/.code={\colorlet{brushcolor}{#1}},
color=red,
distance/.initial=0.4pt
}
\tikzset{
    brush/.style={
        decorate,
        decoration={
            show path construction,
            lineto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,
                 shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                 -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentlast)-(\tikzinputsegmentfirst)$),
                 \n1={90+atan2(\y1,\x1)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 --
                ($(\tikzinputsegmentlast)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
            curveto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentsupporta)-(\tikzinputsegmentfirst)$),
                 \p2=($(\tikzinputsegmentsupportb)-(\tikzinputsegmentsupporta)$),
                 \p3=($(\tikzinputsegmentlast)-(\tikzinputsegmentsupportb)$),
                 \n1={90+atan2(\y1,\x1)}, \n2={90+atan2(\y2,\x2)}, 
                 \n3={90+atan2(\y3,\x3)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 .. controls ($(\tikzinputsegmentsupporta)+(\n2:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                  and ($(\tikzinputsegmentsupportb)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$) ..
                ($(\tikzinputsegmentlast)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
        }
    }
}
\tikzset{pics/.cd,
  A/.style={code={\draw[brush] 
  (0,-0.55) -- (0.3,0.4) -- (0.6,-0.55);
  \draw[brush](0.1,1/3-0.45) --
  (0.5,1/3-0.45);
  \path (0.7,0);}},
  B/.style={code={\draw[brush] (0,-0.45) -- (0,0.45)
  to[out=0,in=0,looseness=2.5]  (0,0)  to[out=0,in=0,looseness=3] cycle;}},
  C/.style={code={\draw[brush]
   (0,0) to[out=90,in=110,looseness=2]  (0.5,0.25);
   \draw[brush](0,0) to[out=-90,in=-110,looseness=2]  (0.5,-0.25);
   \path (0.7,0);}},
  D/.style={code={\draw[brush] (0,-0.45) -- (0,0.45) 
  to[out=0,in=0,looseness=2.25]   cycle;
  \path (0.7,0);}},
  E/.style={code={\draw[brush] 
  (0.5,-0.45) --(0,-0.45) -- (0,0.45)  -- (0.5,0.45);
  \draw[brush] (0,0) -- (0.5,0);
  \path (0.7,0);}},
  F/.style={code={\draw[brush] 
  (0,-0.45) -- (0,0.45)  -- (0.5,0.45);
  \draw[brush] (0,0) -- (0.5,0);
  \path (0.7,0);}},
  G/.style={code={\draw[brush]
   (0,0) to[out=90,in=110,looseness=2]  (0.5,0.25);
   \draw[brush] (0,0) to[out=-90,in=-110,looseness=2]  
   (0.5,-0.25);
   \draw[brush] (0.54,-0.25) to (0.3,-0.25);
   \path (0.7,0);}},
  H/.style={code={\draw[brush] 
  (0,-0.5) -- (0,0.5);  
  \draw[brush] (0.5,-0.5) -- (0.5,0.5);
  \draw[brush] (0,0) -- (0.5,0);
  \path (0.7,0);}},
  I/.style={code={\draw[brush] (0,-0.45) -- (0,0.45);
  \path (0.25,0);}},
  J/.style={code={\draw[brush] (0.2,0.45) -- (0.2,-0.35) to[out=-90,in=0]
  (0.1,-0.45) to[out=180,in=-90] (0,-0.35);
  \path (0.45,0);}},
  K/.style={code={\draw[brush] 
  (0,-0.45) -- (0,0.45); 
  \draw[brush] (0.4,0.45) -- (0.02,0) --  (0.4,-0.45);
  \path (0.6,0);}},
  L/.style={code={\draw[brush] 
  (0,0.5) -- (0,-0.45) -- (0.4,-0.45);
  \path (0.6,0);}},
  M/.style={code={\draw[brush] (0,-0.45) -- (0,0.45) -- 
  (0.3,0.25) -- (0.6,0.45) -- (0.6,-0.45);
  \path (0.8,0);}},
  N/.style={code={\draw[brush] (0,-0.45) -- (0,0.45) -- (0.6,-0.4) --
  (0.6,0.45);
  \path (0.8,0);}},
  O/.style={code={\draw[brush] (0.3,0) circle(0.3 and 0.48);
  \path (0.8,0);}},
  P/.style={code={\draw[brush] (0,-0.45) -- (0,0.45) 
  to[out=0,in=0,looseness=2.5]  (0,0);
  \path (0.6,0);}},
  Q/.style={code={\draw[brush] 
  (0.3,0) circle(0.3 and 0.48);
  \draw[brush](0.35,-0.25) -- (0.6,-0.45);
  \path (0.8,0);}},
  R/.style={code={\draw[brush] 
  (0,-0.45) -- (0,0.45) 
  to[out=0,in=0,looseness=2.5]  (0.05,0) -- (0.4,-0.45);
  \path (0.6,0);}},
  S/.style={code={\draw[brush] (0.5,0.4)  
  to[out=160,in=165,looseness=2]  (0.3,0)  
  to[out=-15,in=-20,looseness=2] (0.1,-0.4);
  \path (0.65,0);}},
  T/.style={code={\draw[brush] (0.35,-0.45) -- (0.35,0.45) (0,0.45) -- (0.7,0.45);
  \path (0.85,0);}},
  U/.style={code={\draw[brush] (0,0.5) -- (0,0) to[out=-90,in=-90,looseness=2.5]
  (0.6,0) -- (0.6,0.5);
  \path (0.8,0);}},
  V/.style={code={\draw[brush] (0,0.5) -- (0.3,-0.4) -- (0.6,0.5);
  \path (0.8,0);}},
  W/.style={code={\draw[brush] (0,0.45) -- (0.3,-0.4) -- (0.45,-0.1)
  -- (0.6,-0.4) -- (0.9,0.45);
  \path (1.1,0);}},
  X/.style={code={\draw[brush] 
  (0,0.45) -- (0.6,-0.45);
   \draw[brush] (0.6,0.45)
  -- (0,-0.45);
  \path (0.8,0);}},
  Y/.style={code={\draw[brush] 
  (0,0.45) -- (0.3,0);  
  \draw[brush] (0.6,0.45)
  -- (0,-0.45);
  \path (0.8,0);}},
  Z/.style={code={\draw[brush] (0,0.45) --(0.6,0.45) -- (0,-0.45)  
  -- (0.6,-0.45);
  \path (0.8,0);}},
  space/.style={code={\path (0,0) (0.2,0);}},
}
\pgfmathdeclarerandomlist{color}{{black}{white}}
\begin{tikzpicture}
 \pic[local bounding box=box1,scale=2] at (0,0) {A};
 \foreach \X [count=\Y,evaluate=\Y as \Z using {int(\Y+1)}] in {B,...,Z}
  {\edef\temp{\noexpand\pic[right=0mm of box\Y,local bounding box=box\Z,scale=2]
  {\X};}
  \temp}
\end{tikzpicture}
\end{document}

Time needed to compile the full alphabet on my machine:

real    0m11.438s
user    0m10.758s
sys 0m0.622s

The letters are taken from this answer and really very quickly written. (They were meant to go into the Christmas extravaganza but didn't make it there for good reasons.)

And within less than 4 minutes (on my machine) you get

\documentclass[tikz,border=3.14mm]{standalone}
\usetikzlibrary{decorations,decorations.pathreplacing,calc,positioning}
\pgfkeys{/brush pars/.cd,
lines/.initial=16,
color/.code={\colorlet{brushcolor}{#1}},
color=red,
distance/.initial=0.4pt
}
\tikzset{
    brush/.style={
        decorate,
        decoration={
            show path construction,
            lineto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,
                 shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                 -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentlast)-(\tikzinputsegmentfirst)$),
                 \n1={90+atan2(\y1,\x1)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 --
                ($(\tikzinputsegmentlast)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
            curveto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentsupporta)-(\tikzinputsegmentfirst)$),
                 \p2=($(\tikzinputsegmentsupportb)-(\tikzinputsegmentsupporta)$),
                 \p3=($(\tikzinputsegmentlast)-(\tikzinputsegmentsupportb)$),
                 \n1={90+atan2(\y1,\x1)}, \n2={90+atan2(\y2,\x2)}, 
                 \n3={90+atan2(\y3,\x3)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 .. controls ($(\tikzinputsegmentsupporta)+(\n2:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                  and ($(\tikzinputsegmentsupportb)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$) ..
                ($(\tikzinputsegmentlast)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
        }
    }
}
\pgfmathdeclarerandomlist{color}{{black}{white}}
\begin{document}
\begin{tikzpicture}
\draw[clip,postaction={fill=red}] (0,0) rectangle (10,10);
\foreach \X in {1,...,1000}
{\draw[brush] (-0.5+11*rnd,-0.5+11*rnd) to[bend left={30-60*rnd}]
++ (360*rnd:1+2*rnd);}

\end{tikzpicture}
\end{document}

And for more aligned strokes you may try

\documentclass[tikz,border=3.14mm]{standalone}
\usetikzlibrary{decorations,decorations.pathreplacing,calc,positioning}
\pgfkeys{/brush pars/.cd,
lines/.initial=16,
color/.code={\colorlet{brushcolor}{#1}},
color=red,
distance/.initial=0.4pt
}
\tikzset{
    brush/.style={
        decorate,
        decoration={
            show path construction,
            lineto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,
                 shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                 -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentlast)-(\tikzinputsegmentfirst)$),
                 \n1={90+atan2(\y1,\x1)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 --
                ($(\tikzinputsegmentlast)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
            curveto code={
                \foreach\Xbrush in{1,...,\pgfkeysvalueof{/brush pars/lines}}{
                 \pgfmathrandomitem{\c}{color}
                 \pgfmathtruncatemacro{\mix}{100-24*rnd}
                 \draw[color=brushcolor!\mix!\c,shorten >={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}},
                 shorten <={(3-4*rnd)*1pt
                    -0.5*\pgfkeysvalueof{/brush pars/lines}*\pgfkeysvalueof{/brush pars/distance}}]
                 let \p1=($(\tikzinputsegmentsupporta)-(\tikzinputsegmentfirst)$),
                 \p2=($(\tikzinputsegmentsupportb)-(\tikzinputsegmentsupporta)$),
                 \p3=($(\tikzinputsegmentlast)-(\tikzinputsegmentsupportb)$),
                 \n1={90+atan2(\y1,\x1)}, \n2={90+atan2(\y2,\x2)}, 
                 \n3={90+atan2(\y3,\x3)} in
                 ($(\tikzinputsegmentfirst)+(\n1:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                 .. controls ($(\tikzinputsegmentsupporta)+(\n2:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$)
                  and ($(\tikzinputsegmentsupportb)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$) ..
                ($(\tikzinputsegmentlast)+(\n3:{((1.02-0.04*rnd)*\Xbrush-\pgfkeysvalueof{/brush pars/lines}/2)*\pgfkeysvalueof{/brush pars/distance}})$);
                }
            },
        }
    }
}
\pgfmathdeclarerandomlist{color}{{black}{white}}
\begin{document}
\begin{tikzpicture}[declare function={VF(\x,\y)=10*\x-4*\y+2*\x*\y;}]
\draw[clip,postaction={fill=red}] (0,0) rectangle (10,10);
\foreach \X in {1,...,1000}
{\pgfmathsetmacro{\myx}{-0.5+11*rnd}
\pgfmathsetmacro{\myy}{-0.5+11*rnd}
\draw[brush] (\myx,\myy) to[bend left={30-60*rnd}]
++ ({VF(\myx,\myy)+10-20*rnd}:1+2*rnd);}
\end{tikzpicture}
\end{document}

Answer 2

This one takes 6 seconds to compile. It is based on my previous answer to the chalkboard texture. The idea is to use dash pattern to reduce the for loop. (Graphic card does the job instead of TeX.)

\documentclass[border=9,tikz]{standalone}
\usetikzlibrary{decorations.pathreplacing}
\begin{document}

\def\niterate{128}
\def\rolldice{
    \pgfmathsetmacro\a{(1+rnd)/10}
    \pgfmathsetmacro\b{5+5*rnd}
    \pgfmathsetmacro\c{1+rnd}
    \pgfmathsetmacro\d{rnd*3}
    \pgfmathsetmacro\dark{rnd*50+50}
}
\tikzset{
    put dots/.style={
        /utils/exec=\rolldice,
        line width=\a,
        dash pattern=on \b off \c,
        dash phase=\c*rnd,
        shift={(rnd*360:\d pt)},
        line cap=round,
        black!\dark,
        opacity=.8
    },
    chalk/.style={
        decorate,
        decoration={
            show path construction,
            lineto code={
                \foreach\i in{1,...,\niterate}{
                    \draw[put dots]
                        (\tikzinputsegmentfirst)--(\tikzinputsegmentlast);
                }
            },
            curveto code={
                \foreach\i in{1,...,\niterate}{
                    \draw[put dots]
                        (\tikzinputsegmentfirst)..controls
                        (\tikzinputsegmentsupporta)and(\tikzinputsegmentsupportb)
                        ..(\tikzinputsegmentlast);
                }
            },
            closepath code={
                \foreach\i in{1,...,\niterate}{
                \draw[put dots]
                    (\tikzinputsegmentfirst)--(\tikzinputsegmentlast);
                }
            }
        }
    }
}

\tikz[looseness=0.25]{
    \path [chalk] (1/8,2) -- (0,1/2) arc (180:315:1/2) (-1/2,3/2)
        to [bend right] (5/8,3/2);
    \path [chalk, shift=(0:1)] (1/8,1) to [bend left] (0,0);
    \path [chalk, shift=(0:3/2)] (1/8,2) to [bend left] (0,0)
         (2/3,1) -- (1/16,2/3) -- (2/3,0);
    \path [chalk, shift=(0:5/2)] (0,1) to [bend left] (1,1)
         to [bend left] (0,0) to [bend left] (1,0);
    \path [chalk] (-1,-3/4) to [bend left] (9/2,-1/2);
}


\message{^^J^^J time = \the\dimexpr\pdfelapsedtime sp (pt means second) ^^J^^J}

\end{document}

---

Some Optimization (not necessary better)

• Start with thick curves with less shifting and more stable color.
  This fills the canvas more efficiently.
• as \i goes up, put thinner and thinner curves with more randomness.
  This creates the brush texture on the top of the base color.
• Use opacity < 1 so that overlapping curves look like more curves.
• The following code uses only 50 bezier curves to replace one bezier curves.
  It takes 3 seconds to compile.

---

\documentclass[border=9,tikz]{standalone}
\usetikzlibrary{decorations.pathreplacing}
\begin{document}

\def\niterate{50}
\def\rolldice{
    \pgfmathsetmacro\rndlinewidth{6/(2+\i)}
    \pgfmathsetmacro\rndon{8+8*rnd}
    \pgfmathsetmacro\rndoff{2*rnd}
    \pgfmathsetmacro\rndshift{sqrt((1-\rndlinewidth/2)*5*rnd)}
    \pgfmathsetmacro\rndblend{50+\i*rand}
}
\tikzset{
    put dashes/.style={
        /utils/exec=\rolldice,
        line width=\rndlinewidth,
        dash pattern=on \rndon off \rndoff,
        dash phase=(\rndon+\rndoff)*rnd,
        shift={(rnd*360:\rndshift pt)},
        line cap=round,
        blue!\rndblend!green,
        opacity=.6
    },
    chalk/.style={
        decorate,
        decoration={
            show path construction,
            lineto code={
                \foreach\i in{1,...,\niterate}{
                    \draw[put dashes]
                        (\tikzinputsegmentfirst)--(\tikzinputsegmentlast);
                }
            },
            curveto code={
                \foreach\i in{1,...,\niterate}{
                    \draw[put dashes]
                        (\tikzinputsegmentfirst)..controls
                        (\tikzinputsegmentsupporta)and(\tikzinputsegmentsupportb)
                        ..(\tikzinputsegmentlast);
                }
            },
            closepath code={
                \foreach\i in{1,...,\niterate}{
                \draw[put dashes]
                    (\tikzinputsegmentfirst)--(\tikzinputsegmentlast);
                }
            }
        }
    }
}

\tikz[looseness=0.25]{
    \path [chalk] (1/8,2) -- (0,1/2) arc (180:315:1/2) (-1/2,3/2)
        to [bend right] (5/8,3/2);
    \path [chalk, shift=(0:1)] (1/8,1) to [bend left] (0,0);
    \path [chalk, shift=(0:3/2)] (1/8,2) to [bend left] (0,0)
         (2/3,1) -- (1/16,2/3) -- (2/3,0);
    \path [chalk, shift=(0:5/2)] (0,1) to [bend left] (1,1)
         to [bend left] (0,0) to [bend left] (1,0);
    \path [chalk] (-1,-3/4) to [bend left] (9/2,-1/2);
}


\message{^^J^^J time = \the\numexpr\pdfelapsedtime*1000/65536 ms ^^J^^J}

\end{document}

Answer 3

I've finally gotten around to finishing my answer to this question. It took a while and I feel a little guilty about it in light of the amount of reputation this question has gained me. Anyway, here is the “final” (for now) version: it's faster and more customisable than the previous one. A lot of time was saved by using the \pgfpath… macros instead of \draw and avoiding \pgfmath, which is really slow. If you want to see the old version you can look at my previous edit.

Filling a square

Since you specifically wanted to fill a region with brush strokes, here is a way to do that. The following code takes about 11 seconds to execue on my computer:

\documentclass[tikz,margin=10pt]{standalone}
\usetikzlibrary{decorations.pathreplacing}

\makeatletter %% <- make @ usable in macro names
\pgfkeys{/pgf/decoration/brush/.cd,
         thickness/.initial      = 10pt,     %% <- total brush stroke width
         hair separation/.initial= .3pt,     %% <- avg. distance between hairs on the brush
         hair thickness/.initial = .4pt,     %% <- min. thickness of the individual hairs
         hair amplitude/.initial =.25pt,     %% <- amplitude of hair thickness oscillation
         min period/.initial     = 9pt,      %% <- min. value for the period of both oscillations
         max period/.initial     = 18pt,     %% <- max. value for the period of both oscillations
         period/.style           = {min period=#1,max period=#1},
         max overshoot/.initial  = 3pt,      %% <- max. distance hairs can overshoot at the end
         color 1/.initial        = red!90!black, %% <- primary colour
         color 2/.initial        = br@color1!80!black, %% <- secondary colour (slightly darker by default)
         color/.style            = {color 1=#1,color 2=br@color1!80!black}, %% color
         hair color/.initial     = black,    %% <- only used internally
         hair offset/.initial    = 0pt,      %% <- only used internally
}

%% Some fixed-point arithmetic operations using lengths
%% (N.B. both input and output are dimension registers but should be thought of as numbers)
\newcommand*\fpdivide[2]{%
  \dimexpr\numexpr #1*65536/#2\relax sp\relax
}

%% Human readable names for the dimensions used in \qsplitbezier:
\def\br@bezFrstAx {\dimen0} \def\br@bezFrstBx{ \dimen2} \def\br@bezFrstCx{\dimen4}
\def\br@bezFrstAy {\dimen6} \def\br@bezFrstBy {\dimen8} \def\br@bezFrstCy{\dimen10}
\def\br@bezScndAx{\dimen12} \def\br@bezScndBx{\dimen14} \def\br@bezThrdx {\dimen16}
\def\br@bezScndAy{\dimen18} \def\br@bezScndBy{\dimen20} \def\br@bezThrdy {\dimen22}
\newif\iffirstcomponent
%% Split up a Bézier curve with control points #2, #3, #4 and #5 at #1:
%%   (#1 is normally a parametric length between 0 and 1, but extrapolation is also possible)
\newcommand*\qsplitbezier[5]{\begingroup\edef\x{\endgroup\noexpand\qsplitbezier@{#1}#2#3#4#5\noexpand\qsplitbezier@}\x}
\def\qsplitbezier@#1(#2,#3)(#4,#5)(#6,#7)(#8,#9)\qsplitbezier@{%
  \begingroup
    \edef\s{#1}%
    %% Allow extrapolation but prevent numerical overflows:
    \ifdim\s pt>9pt \def\s{9}\fi
    \ifdim\s pt<-8pt \def\s{-8}\fi
    \edef\t{\strip@pt\dimexpr 1pt-\s pt}%
    %% Linear curves:
    \br@bezFrstAx=\dimexpr\t\dimexpr#2\relax+\s\dimexpr#4\relax
    \br@bezFrstAy=\dimexpr\t\dimexpr#3\relax+\s\dimexpr#5\relax
    \br@bezFrstBx=\dimexpr\t\dimexpr#4\relax+\s\dimexpr#6\relax
    \br@bezFrstBy=\dimexpr\t\dimexpr#5\relax+\s\dimexpr#7\relax
    \br@bezFrstCx=\dimexpr\t\dimexpr#6\relax+\s\dimexpr#8\relax
    \br@bezFrstCy=\dimexpr\t\dimexpr#7\relax+\s\dimexpr#9\relax
    %% Quadratic curves:
    \br@bezScndAx=\dimexpr\t\br@bezFrstAx+\s\br@bezFrstBx\relax
    \br@bezScndAy=\dimexpr\t\br@bezFrstAy+\s\br@bezFrstBy\relax
    \br@bezScndBx=\dimexpr\t\br@bezFrstBx+\s\br@bezFrstCx\relax
    \br@bezScndBy=\dimexpr\t\br@bezFrstBy+\s\br@bezFrstCy\relax
    %% Cubic curve:
    \br@bezThrdx=\dimexpr\t\br@bezScndAx+\s\br@bezScndBx\relax
    \br@bezThrdy=\dimexpr\t\br@bezScndAy+\s\br@bezScndBy\relax
    %% Store output in macros:
    \edef\x{\endgroup %% <-- perform assignments outside the group
      \def\noexpand\bezOneStart{#2,#3}%
      \def\noexpand\bezOneControlA{\the\br@bezFrstAx,\the\br@bezFrstAy}%
      \def\noexpand\bezOneControlB{\the\br@bezScndAx,\the\br@bezScndAy}%
      \def\noexpand\bezOneEnd{\the\br@bezThrdx,\the\br@bezThrdy}%
      \def\noexpand\bezTwoStart{\the\br@bezThrdx,\the\br@bezThrdy}%
      \def\noexpand\bezTwoControlA{\the\br@bezScndBx,\the\br@bezScndBy}%
      \def\noexpand\bezTwoControlB{\the\br@bezFrstCx,\the\br@bezFrstCy}%
      \def\noexpand\bezTwoEnd{#8,#9}%
    }\x
}
%% Split up straight lines (so we can turn them into Bézier curves)
\newcommand*\splitstraighttwice[4]{\begingroup\edef\x{\endgroup\noexpand\splitstraight@{#1}#2#3\noexpand#4\noexpand\splitstraight@}\x}
\def\splitstraight@#1(#2,#3)(#4,#5)#6\splitstraight@{%
  \begingroup
    \pgfmathsetmacro\t{#1}%
    \pgfpointlineattime{\t}{\pgfpoint{#2}{#3}}{\pgfpoint{#4}{#5}}%
    \edef#6{\the\pgf@x,\the\pgf@y}%
    \pgfmath@smuggleone#6%
   \endgroup
}
%% Orthogonal translation of the endpoints of a Bézier curve
\newcommand*\shiftbezier[6]{%
  \begingroup\edef\x{\endgroup
    %% Translate starting point
    \unexpanded{\shiftbezier@{\dimexpr#1\relax}}#3#4\unexpanded{\bezOneStart\bezOneControlA\shiftbezier@}%
    %% Translate end point
    \unexpanded{\shiftbezier@{\dimexpr#2\relax}}#5#6\unexpanded{\bezOneControlB\bezOneEnd\shiftbezier@}%
  }\x
}
\def\shiftbezier@#1(#2,#3)(#4,#5)#6#7\shiftbezier@{%
  %% This method is faster than \pgfpointnormalise + \pgfpointscale
  \begingroup
    %% Determine the angle with the positive x-axis:
    \@nameuse{pgfmathatan2@}{\strip@pt\dimexpr#5-#3\relax}{\strip@pt\dimexpr#4-#2\relax}%
    %% Construct a vector of length #1 in the same direction:
    \let\pgf@tmp\pgfmathresult
    \pgfmathcos@{\pgf@tmp}%
    \pgf@x=\pgfmathresult\dimexpr#1\relax
    \pgfmathsin@{\pgf@tmp}%
    \pgf@y=\pgfmathresult\dimexpr#1\relax
    %% Add a 90 degree rotated version of it to (#2,#3) and (#4,#5) and store in #6 resp. #7:
  \edef\x{\endgroup %% <-- perform assignments outside the group
    \def\noexpand#6{\the\dimexpr#2-\pgf@y,\the\dimexpr#3+\pgf@x}%
    \def\noexpand#7{\the\dimexpr#4-\pgf@y,\the\dimexpr#5+\pgf@x}%
  }\x
}

%% The brush hair decoration code, separated to avoid code duplication
\newcommand*\br@haircurvetocode{%
  %%%%%%%%%%%%
  %% Setup: %%
  %%%%%%%%%%%%
  \color{\pgfkeysvalueof{/pgf/decoration/brush/hair color}}
  \pgfsys@setlinewidth{\br@hairwidth}
  \edef\br@hairoffset{\pgfkeysvalueof{/pgf/decoration/brush/hair offset}}
  \pgfmathrandom{2}
  \edef\br@hairamplitude{\the\dimexpr\br@amplitude*(\pgfmathresult*2-3)}
  \edef\br@period@var{\the\dimexpr\br@period@max-\br@period@min}

  \ifdim\pgfdecoratedcompleteddistance<1pt %% <-- start of curve?
    %% Set the length of the first segment:
    \pgfmathrnd
    \edef\br@segmlength{\the\dimexpr\br@period@min+\pgfmathresult\dimexpr\br@period@var}
    %% Use a random initial phase for the thickness oscillation:
    \pgfmathrnd
    \edef\br@segmoffset{\the\dimexpr\pgfmathresult\dimexpr\br@segmlength}
    %% Introcude a random overshoot at the start:
    \pgfmathrnd
    \edef\br@extension@pre{\the\dimexpr\pgfmathresult\dimexpr\br@overshoot}
  \else                                    %% <-- not start of curve?
    %% Set appropriate values for non-initial segments:
    \let\br@segmoffset\br@segmoffset@stored
    \let\br@segmlength\br@segmlength@stored
    \let\br@hairamplitude\br@hairamplitude@stored
    \def\br@extension@pre{0pt}
  \fi
  \ifdim\dimexpr\pgfdecoratedremainingdistance-\pgfdecoratedinputsegmentlength<1pt %% <-- end of segment?
    %% Introduce a random overshoot at the end:
    \pgfmathrnd
    \edef\br@extension@post{\the\dimexpr\pgfmathresult\dimexpr\br@overshoot}
  \else
    \def\br@extension@post{0pt}
  \fi

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %% Extrapolate by \br@segmoffset at the start: %%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  %% Make the first subsegment long enough to fit half a period:
  \edef\br@placetosplit{\strip@pt\fpdivide{-\dimexpr\br@segmoffset\relax}{\dimexpr\pgfdecoratedinputsegmentlength\relax}}
  \qsplitbezier{\br@placetosplit} {(\tikzinputsegmentfirst)}    {(\tikzinputsegmentsupporta)}
                                  {(\tikzinputsegmentsupportb)} {(\tikzinputsegmentlast)}
  %% Adjust the remaining length:
  \edef\br@remaininglength{\the\dimexpr\pgfdecoratedinputsegmentlength+\br@segmoffset}
  %% Then reduce \br@segmoffset so that slightly less will be cut off later:
  \ifdim\br@extension@pre=0pt\else
    \edef\br@segmoffset{\the\dimexpr\br@segmoffset-\br@extension@pre}
  \fi

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %% Loop until we've drawn the entire segment %%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \loop
    %% Split up the Bézier curve to isolate the first subsegment:
    \edef\br@placetosplit{\strip@pt\fpdivide{\dimexpr\br@segmlength\relax}{\dimexpr\br@remaininglength\relax}}
    \qsplitbezier{\br@placetosplit} {(\bezTwoStart)}    {(\bezTwoControlA)}
                                    {(\bezTwoControlB)} {(\bezTwoEnd)}
    %% Draw the central part of the hair:
    \br@haircurvetocode@{\br@hairoffset}{\br@hairoffset}
    %% Draw the oscillating part of the hair:
    \edef\br@hairoffset@first{\the\dimexpr\br@hairoffset+\br@hairamplitude}
    \edef\br@hairoffset@second{\the\dimexpr\br@hairoffset-\br@hairamplitude}
    \br@haircurvetocode@{\br@hairoffset@first}{\br@hairoffset@second}

  %% Test if the loop should be continued:
  \ifdim\br@remaininglength>\br@segmlength
    %% Adjust the remaining length:
    \edef\br@remaininglength{\the\dimexpr\br@remaininglength-\br@segmlength}
    %% Ensure that the next subsegment starts from the beginning:
    \def\br@segmoffset{0pt}
    %% Flip the hair amplitude:
    \edef\br@hairamplitude{\the\dimexpr-\br@hairamplitude}
    %% Set the length of the next subsegment: (maybe a little gratuitous?)
    \pgfmathrnd
    \edef\br@segmlength{\the\dimexpr\pgfmathresult\dimexpr\br@period@var\relax+\br@period@min}
  %% And repeat:
  \repeat
  %% Store values to be used  by the next subsegment:
  \global\let\br@segmoffset@stored\br@remaininglength
  \global\let\br@segmlength@stored\br@segmlength
  \global\let\br@hairamplitude@stored\br@hairamplitude
}

%% Separated the code that performs draws the segments to avoid code duplication:
\newcommand*\br@haircurvetocode@[2]{
  \begingroup
    %% Translate the curve's endpoints by #1 at one end and by #2 on the other:
    \shiftbezier{#1}{#2} {(\bezOneStart)} {(\bezOneControlA)} {(\bezOneControlB)} {(\bezOneEnd)}
    %% Throw away a bit at the start if this is the first segment:
    \ifdim\br@segmoffset=0pt\else
      \edef\br@placetosplit{\strip@pt\fpdivide{\dimexpr\br@segmoffset\relax}{\dimexpr\br@segmlength\relax}}
      \qsplitbezier{\br@placetosplit} {(\bezOneStart)}    {(\bezOneControlA)}
                                      {(\bezOneControlB)} {(\bezOneEnd)}
      \let\bezOneStart\bezTwoStart
      \let\bezOneEnd\bezTwoEnd
      \let\bezOneControlA\bezTwoControlA
      \let\bezOneControlB\bezTwoControlB
      \edef\br@segmlength{\the\dimexpr\br@segmlength-\br@segmoffset}
      \edef\br@remaininglength{\the\dimexpr\br@remaininglength-\br@segmoffset}
    \fi
    %% Throw away a bit at the end if this is the last segment:
    \ifdim\br@segmlength>\br@remaininglength
      \edef\br@placetosplit{\strip@pt\fpdivide{\dimexpr\br@remaininglength+\br@extension@post\relax}{\dimexpr\br@segmlength\relax}}
      \qsplitbezier{\br@placetosplit} {(\bezOneStart)}    {(\bezOneControlA)}
                                      {(\bezOneControlB)} {(\bezOneEnd)}
    \fi
    %% Draw the subsegment:
    \pgfpathmoveto{\br@pairtopgfpoint{\bezOneStart}}
    \pgfpathcurveto{\br@pairtopgfpoint{\bezOneControlA}}
                   {\br@pairtopgfpoint{\bezOneControlB}}
                   {\br@pairtopgfpoint{\bezOneEnd}}
    \pgfsetroundcap
    \pgfusepathqstroke
  \endgroup
}
\def\br@pairtopgfpoint#1{\expandafter\br@pairtopgfpoint@#1\br@pairtopgfpoint@}
\def\br@pairtopgfpoint@#1,#2\br@pairtopgfpoint@{\pgfpoint{#1}{#2}}

%% Define the brush and brush hair styles
\tikzset{
  brush hair@internal/.style={
    decorate,
    decoration={
      show path construction,
      curveto code={
        \br@haircurvetocode
      },
      lineto code={
        %% Turn this straight line into a Bézier curves and draw those
        \splitstraighttwice{0.333333}{(\tikzinputsegmentfirst)}{(\tikzinputsegmentlast)}\tikzinputsegmentsupporta
        \splitstraighttwice{0.666667}{(\tikzinputsegmentfirst)}{(\tikzinputsegmentlast)}\tikzinputsegmentsupportb
        \br@haircurvetocode
      },
      closepath code={
        \ifdim\pgfdecoratedremainingdistance<1pt\else %% <-- don't do anything if there is no distance to cover
          %% Turn this straight line into a Bézier curve and draw that
          \splitstraighttwice{0.333333}{(\tikzinputsegmentfirst)}{(\tikzinputsegmentlast)}\tikzinputsegmentsupporta
          \splitstraighttwice{0.666667}{(\tikzinputsegmentfirst)}{(\tikzinputsegmentlast)}\tikzinputsegmentsupportb
          \br@haircurvetocode
        \fi
      }
    }
  },
  brush/.code={
    %% Retrieve key values:
    \pgfqkeys{/pgf/decoration/brush}{#1}
    \colorlet{br@color1}{\pgfkeysvalueof{/pgf/decoration/brush/color 1}}
    \colorlet{br@color2}{\pgfkeysvalueof{/pgf/decoration/brush/color 2}}
    \pgfmathsetlength{\@tempdima}{\pgfkeysvalueof{/pgf/decoration/brush/hair separation}}
    \pgfmathsetcount{\@tempcnta}{\pgfkeysvalueof{/pgf/decoration/brush/thickness}/\the\@tempdima}
    \pgfmathsetlengthmacro{\br@amplitude}{\pgfkeysvalueof{/pgf/decoration/brush/hair amplitude}}
    \pgfmathsetlengthmacro{\br@period@min}{\pgfkeysvalueof{/pgf/decoration/brush/min period}}
    \pgfmathsetlengthmacro{\br@period@max}{\pgfkeysvalueof{/pgf/decoration/brush/max period}}
    \pgfmathsetlengthmacro{\br@overshoot}{\pgfkeysvalueof{/pgf/decoration/brush/max overshoot}}
    \pgfmathsetlengthmacro{\br@hairwidth}{\pgfkeysvalueof{/pgf/decoration/brush/hair thickness}}
    %% Draw brush stroke:
    \loop
      %% Randomise colour mixing:
      \pgfmathrandom{1,100}
      \begingroup\edef\x{\endgroup
        \noexpand\tikzset{postaction={
          brush hair@internal,
          /pgf/decoration/brush/hair color=br@color1!\pgfmathresult!br@color2,
          /pgf/decoration/brush/hair offset=\the\dimexpr.5\@tempdima*\@tempcnta},
        }
      }\x
      %% Abort after a central hair is drawn:
      \ifnum\@tempcnta=0
        \@tempcnta=-1
      \fi
      %% Decrement @\tempcnta every other iteration:
      \ifdim\@tempdima>0pt\else
        \advance\@tempcnta by -2
      \fi
      %% Flip the sign of the offset:
      \@tempdima=-\@tempdima
    \ifnum\@tempcnta>-1\repeat
  }
}
\makeatother

\begin{document}
%% Set up counter for timing purposes:
\newcount\lastpdfelapsedtime
\lastpdfelapsedtime=\pdfelapsedtime

\begin{tikzpicture}
  %% Clipping:
  \clip (-4.5,-4.5) rectangle (4.5,4.5);
  %% Background:
  \path[brush={color=red!90!black,
               thickness=10cm,
               hair amplitude=2.5pt,
               min period=90pt,
               max period=180pt,
               hair thickness=4.5pt,
               hair separation=3pt,
                 max overshoot=0pt,
              }] (-5.5,0) to[out=10,in=190,looseness=1] (5.5,0);
  %% Some individual strokes:
  \def\numbrushstrokes{12}
  \foreach \i in {1,...,\numbrushstrokes} {
  \typeout{\i/\numbrushstrokes} %% <- progress meter
    \pgfmathsetmacro{\outangle}{rand*30}
    \pgfmathsetmacro{\inangle}{180+rand*30}
    \pgfmathsetmacro{\curveycentre}{rand*5}
    \pgfmathsetmacro{\curveyvariation}{rand/2}
    \pgfmathsetmacro{\colormixing}{75+rnd*20}
    \pgfmathsetmacro{\blf}{rand*10}
    \pgfmathsetmacro{\curvecentre}{rand*5}
    \pgfmathsetmacro{\curvelength}{2+rnd*3}
    \path[brush={color=red!\colormixing!black,
                 thickness=2cm,
                 hair amplitude=2.5pt,
                 min period=90pt,
                 max period=180pt,
                 hair thickness=4pt,
                 hair separation=3pt,
                 max overshoot=30pt,
                }] (\curvecentre-\curvelength,\curveycentre-\curveyvariation) to[out=\outangle,in=\inangle,looseness=1] (\curvecentre+\curvelength,\curveycentre+\curveyvariation);
  }
\end{tikzpicture}

\message{Elapsed time: \the\numexpr(\pdfelapsedtime-\lastpdfelapsedtime)*1000/65536\relax\space ms.}
\end{document}

The preamble is really long because the brush decoration that I'm defining, and subsequently using, is quite complicated. I'll say a bit more about it at the bottom of this post.

N.B. Because it is generated randomly, the outcome doesn't look as good every time.

---

My original drawing

I originally drew a stick figure, so I'll do so again. I couldn't include the preamble in this document because answers have a character limit of 30 000, so you'll need to copy the preamble from above. The image below takes about 5 seconds to produce.

\documentclass[tikz,margin=10pt]{standalone}
\includetikzlibrary{decorations.pathreplacing}

<Insert long preamble from before>

\begin{document}
%% Set up counter for timing purposes:
\newcount\lastpdfelapsedtime
\lastpdfelapsedtime=\pdfelapsedtime

\begin{tikzpicture}
  %% The legs: (yellow)
  \path[brush={color 1=yellow!95!red,  %% <- yellow
              }](0,-2) -- (1,0) -- (2,-2);
  %% The arms: (different orange hues)
  \path[bend right=20,
        brush={color 1=orange!70!yellow,         %% <- orange
               color 2=orange!70!red!95!black, %% <- transitioning to reddish orange
              }] (-1,2.5) to (3,2.5);
  %% The head: (red, thinner and undershoots)
  \path[brush={color=red!90!black,     %% <- darkish red
               thickness=6.7pt,        %% <- make the circle thinner
               max overshoot=-1.5mm,   %% <- negative overshoot = undershoot
              }] (1,4) circle[radius=1];
  %% The body: (green with some blue)
  \path[brush={color 1=green!80!black, %% <- darkish green
               color 2=green!70!blue!80!black, %% <- with a little blue mixed in
              }] (1,0) to[out=80,in=260,looseness=1] (1,3);
\end{tikzpicture}

\message{Elapsed time: \the\numexpr(\pdfelapsedtime-\lastpdfelapsedtime)*1000/65536\relax\space ms.}
\end{document}

---

The brush decoration

The sole purpose of the preamble of the documents above is to define the brush decoration. This decoration replaces a curve by whole bunch of slightly offset parallel curves whose thicknesses vary from point to point. The basic syntax is as follows:

\path[<path options>,brush={color=<color>}] <path specification>;

where <path options> can be something like bend right=20, <color> is a colour and <path specification> could be e.g. (0,0) -- (1,0). This will produce a brush stroke which consists of a lot of individual strokes that have colours ranging between <color> and <color>!80!black (a slightly darker version of the same colour). It should be noted that paths with corners won't look good.

It is also possible to specify two colours as follows:

\path[<path options>,brush={color 1=<color>, color 2=<color>}] <path specification>;

There are a couple of other options that can be provided in addition to the colour:

thickness = thickness of the full brush stroke
hair thickness = minimal thickness of individual hairs
hair separation = distance between individual hairs
hair amplitude = the amount by which the hair thickness can vary
min period = the minimum distance between consecutive thin/thick parts
max period = the maximum distance between consecutive thin/thick parts
max overshoot = the maximum amount by which hairs can extend beyond the end of the original curve

The number of hairs to be drawn is calculated from the total thickness of the brush stroke and the hair separation. There are some restrictions: both hair separation and hair amplitude should both be less than hair thickness to prevent gaps.

You can see what a single brush hair looks like by setting thickness to 0pt:

\documentclass[tikz,margin=10pt]{standalone}
\includetikzlibrary{decorations.pathreplacing}

<insert long preamble from above again>

\begin{document}
\begin{tikzpicture}
  \path[brush={color=blue,thickness=0pt}] (0,0) -- (2,0);
\end{tikzpicture}
\end{document}

It actually consists of two curves: one straight curve and another curve that is sort of orbiting around it. To create it I've had to write some code that splits up arbitrary Bézier curves. I think this bit of the code would also be useful by itself, but don't currently have another application for it.

---

Bonus

Here is a picture of a beanstalk I made by accident while tweaking some numbers. No one asked for this, but I couldn't just throw it away…

\documentclass[tikz,margin=10pt]{standalone}

<insert long preamble here>

\begin{document}
\begin{tikzpicture}
  \path[brush={color 1=green!80!black,
               color 2=green!70!blue!80!black,
               hair amplitude=2.5pt,
              }] (1,0) to[out=80,in=260,looseness=1] (1,3);
\end{tikzpicture}
\end{document}