diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index 670a1b1..9b9444c 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,12 +1,12 @@
 [bumpversion]
-current_version = 0.3.0
+current_version = 0.4.0
 commit = False
 message = bump: {current_version} --> {new_version}
 tag = False
 tag_name = {current_version}
-tag_message =
+tag_message = 
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(?P<rc_kind>[A-Za-z]*)(?P<rc>\d*)
-serialize =
+serialize = 
 	{major}.{minor}.{patch}{rc_kind}{rc}
 	{major}.{minor}.{patch}
 
diff --git a/.copier-answers.yml b/.copier-answers.yml
index 227551e..2e891e4 100644
--- a/.copier-answers.yml
+++ b/.copier-answers.yml
@@ -1,5 +1,5 @@
 # Changes here will be overwritten by Copier
-_commit: a01a11e
+_commit: b7e79bf
 _src_path: https://codeberg.org/Fresh2dev/copier-f2dv-project.git
 author_email: hello@f2dv.com
 author_name: Donald Mellenbruch
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f487a11..80d2016 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,16 @@
 # Changelog
 
-## 0.3.0
+## 0.4.0 - 2023-08-04
+
+### :point_right: Changes
+
+- *Breaking:* Default engine changed from `threading.Thread` to `mp.Process` [a3dc1af]
+
+### :metal: Other
+
+- Correct annotations and docstrings [7a2470a]
+
+## 0.3.0 - 2023-06-22
 
 - rename from `ezpq` to `ppqueue`
 - replaced `queue.get` with `queue.dequeue` / `queue.pop`
diff --git a/README.pypi.md b/README.pypi.md
new file mode 100644
index 0000000..a8a7fb7
--- /dev/null
+++ b/README.pypi.md
@@ -0,0 +1 @@
+[https://www.f2dv.com/r/ppqueue](https://www.f2dv.com/r/ppqueue)
diff --git a/config/overrides/main.html b/config/overrides/main.html
index a931321..6fc7871 100644
--- a/config/overrides/main.html
+++ b/config/overrides/main.html
@@ -8,7 +8,7 @@
 
 {% block fonts %}
 <style>
-@import url("https://www.fresh2.dev/assets/css/fonts.css");
+@import url("https://www.fresh2.dev/css/fonts.css");
 
 :root {
   --md-text-font: iAWriterQuattroS, -apple-system, BlinkMacSystemFont, avenir next, avenir, segoe ui, helvetica neue, helvetica, Ubuntu, roboto, noto, arial, sans-serif;
diff --git a/pyproject.toml b/pyproject.toml
index e3ef82c..1026afb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,7 @@ authors = [
     {name = "Donald Mellenbruch", email = "hello@f2dv.com"},
 ]
 description = "A Parallel Process Queue for Python."
-readme = "README.md"
+readme = "README.pypi.md"
 license = {file = "LICENSE"}
 requires-python = ">=3.8"
 classifiers = [
diff --git a/src/ppqueue/__version__.py b/src/ppqueue/__version__.py
index 493f741..6a9beea 100644
--- a/src/ppqueue/__version__.py
+++ b/src/ppqueue/__version__.py
@@ -1 +1 @@
-__version__ = "0.3.0"
+__version__ = "0.4.0"
diff --git a/src/ppqueue/job.py b/src/ppqueue/job.py
index b3b36f4..5ee0094 100644
--- a/src/ppqueue/job.py
+++ b/src/ppqueue/job.py
@@ -68,16 +68,16 @@ def __post_init__(self) -> None:
         if self.kwargs is None:
             self.kwargs = {}
 
-    def _compare(self, job: object) -> int:
+    def _compare(self, job: Job) -> int:
         """compares two jobs by priority or index.
 
         Arguments:
-            job {ppqueue.Job}
+            job: ...
 
         Returns:
-            int -- `1` if `self` is greater than comparison,
-                  `-1` if `self` is less than,
-                  `0` if equal.
+            `1` if `self` is greater than comparison,
+            `-1` if `self` is less than,
+            `0` if equal.
         """
         return compare_by(self, job, by=["priority", "idx"])
 
@@ -117,7 +117,11 @@ def join(self, *args, **kwargs) -> None:
             self.inner_job.join(*args, **kwargs)
 
     def get_exit_code(self) -> int | None:
-        """Exit code of the job."""
+        """Exit code of the job.
+
+        Returns:
+            ...
+        """
         if (
             not self.inner_job
             or not hasattr(self.inner_job, "exitcode")
@@ -146,6 +150,9 @@ def stop(self) -> None:
     def get_seconds_running(self) -> float | None:
         """The number of seconds a job was running for.
 
+        Returns:
+            ...
+
         Examples:
             >>> from ppqueue import Queue
             >>> from time import sleep
@@ -164,6 +171,9 @@ def get_seconds_running(self) -> float | None:
     def get_seconds_waiting(self) -> float | None:
         """The amount of time a data has spent in the waiting queue.
 
+        Returns:
+            ...
+
         Examples:
             >>> job.get_seconds_waiting()  # doctest: +SKIP
         """
@@ -178,6 +188,9 @@ def get_seconds_waiting(self) -> float | None:
     def get_seconds_total(self) -> float | None:
         """Returns the waiting + running duration of this job.
 
+        Returns:
+            ...
+
         Examples:
             >>> job.get_seconds_total()  # doctest: +SKIP
         """
@@ -192,6 +205,9 @@ def get_seconds_total(self) -> float | None:
     def get_submit_timestamp(self) -> datetime | None:
         """The time this job was submitted.
 
+        Returns:
+            ...
+
         Examples:
             >>> job.get_submit_timestamp()  # doctest: +SKIP
         """
@@ -200,19 +216,31 @@ def get_submit_timestamp(self) -> datetime | None:
         return None
 
     def get_start_timestamp(self) -> datetime | None:
-        """Returns a datetime object of the time this data was started."""
+        """Returns a datetime object of the time this data was started.
+
+        Returns:
+            ...
+        """
         if self.start_timestamp:
             return datetime.utcfromtimestamp(self.start_timestamp)
         return None
 
     def get_finish_timestamp(self) -> datetime | None:
-        """Returns a datetime object of the time this data finished."""
+        """Returns a datetime object of the time this data finished.
+
+        Returns:
+            ...
+        """
         if self.finish_timestamp:
             return datetime.utcfromtimestamp(self.finish_timestamp)
         return None
 
     def get_processed_timestamp(self) -> datetime | None:
-        """Returns a datetime object of the time this data was processed."""
+        """Returns a datetime object of the time this data was processed.
+
+        Returns:
+            ...
+        """
         if self.process_timestamp:
             return datetime.utcfromtimestamp(self.process_timestamp)
         return None
diff --git a/src/ppqueue/plot.py b/src/ppqueue/plot.py
index 4c2c82b..dca0c47 100644
--- a/src/ppqueue/plot.py
+++ b/src/ppqueue/plot.py
@@ -222,15 +222,19 @@ def plot_jobs(
     """
 
     Args:
-        title:
-        color_by:
-        facet_by:
-        facet_scale:
-        theme:
-        no_legend:
-        bar_width:
+        *args: Sequences of `Job` instances to plot.
+        title: ...
+        color_by: ...
+        facet_by: ...
+        facet_scale: ...
+        theme: ...
+        no_legend: ...
+        bar_width: ...
         color_pal: a sequence of colors used to color each group of `color_by`.
 
+    Returns:
+        ...
+
     Examples:
         >>> from ppqueue import Queue
         >>> from ppqueue.plot import plot_jobs
diff --git a/src/ppqueue/queue.py b/src/ppqueue/queue.py
index 384ccb4..876af42 100644
--- a/src/ppqueue/queue.py
+++ b/src/ppqueue/queue.py
@@ -6,7 +6,7 @@
 import time
 import traceback
 from heapq import heappop, heappush
-from typing import Any, Callable, Sequence, Type
+from typing import Any, Callable, Sequence
 from uuid import uuid4
 
 from tqdm.auto import tqdm
@@ -18,10 +18,8 @@
 
 
 class PulseTimer:
-    """Periodically runs a function in a background thread.
-
-    ref: https://stackoverflow.com/a/13151299
-    """
+    # Periodically runs a function in a background thread.
+    # src: https://stackoverflow.com/a/13151299
 
     def __init__(
         self,
@@ -75,7 +73,7 @@ def __init__(
         max_concurrent: int = mp.cpu_count(),
         *,
         max_size: int = 0,
-        engine: Type[threading.Thread] | Type[mp.Process] = threading.Thread,
+        engine: str | type[mp.Process] | type[threading.Thread] = mp.Process,
         name: str | None = None,
         callback: Callable[[Job], Any] | None = None,
         show_progress: bool = False,
@@ -84,12 +82,12 @@ def __init__(
         pulse_freq_ms: int = 100,
         no_start: bool = False,
     ):
-        """
+        """A parallel processing job runner / data structure.
 
         Args:
             max_concurrent: max number of concurrently running jobs.
             max_size: max size of the queue (default=0, unlimited).
-            engine: the engine used to run jobs; threads (default) or processes.
+            engine: the engine used to run jobs.
             name: an identifier for this queue.
             callback: a callable that is called immediately after each job is finished.
             show_progress: global setting for showing progress bars.
@@ -118,9 +116,22 @@ def __init__(
         self._max_concurrent: int = max_concurrent
         self._callback: Callable[..., Any] | None = callback
 
-        self._lock: threading.Lock = (
-            threading.Lock()
-        )  # https://opensource.com/article/17/4/grok-gil
+        # https://opensource.com/article/17/4/grok-gil
+        self._lock: threading.Lock = threading.Lock()
+
+        if isinstance(engine, str):
+            if engine.lower() in ["thread", "threads", "threading"]:
+                engine = threading.Thread
+            elif engine.lower() in [
+                "process",
+                "processes",
+                "processing",
+                "multiprocessing",
+            ]:
+                engine = mp.Process
+            else:
+                err: str = f"Unrecognized engine: {engine}. Choose either 'process' or 'thread'."
+                raise ValueError(err)
 
         if engine is mp.Process and is_windows_os():
             LOG.warning(
@@ -130,9 +141,9 @@ def __init__(
                 ),
             )
 
-        self._engine: Type[mp.Process] | Type[threading.Thread] = engine
+        self._engine: type[mp.Process] | type[threading.Thread] = engine
 
-        self._waiting_groups: dict[int | None, list[Job]] = {None: []}
+        self._waiting_groups: dict[int | None, list[Job]] = {self.DEFAULT_GROUP: []}
         self._working_queue: dict[int | None, Job] = {}
         self._finished_queue: list[Job] = []
 
@@ -155,11 +166,11 @@ def __init__(
             fun=self._pulse,
         )
 
+        self._stop_when_idle: bool = stop_when_idle
+
         if not no_start:
             self.start()
 
-        self._stop_when_idle: bool = stop_when_idle
-
         LOG.debug("Initialized pulse.")
 
     # decorator
@@ -208,8 +219,6 @@ def dispose(self) -> None:
             self._mp_manager.shutdown()
 
     def _clear_waiting(self) -> None:
-        """Clear the queue of pending jobs."""
-
         LOG.debug("Clearing waiting queue")
         with self._lock:
             keys = list(self._waiting_groups.keys())
@@ -226,8 +235,6 @@ def _clear_waiting(self) -> None:
                 del self._waiting_groups[k]
 
     def _stop_all(self, *, wait: bool = True) -> None:
-        """Stop and remove all running and waiting jobs."""
-
         self._clear_waiting()
 
         keys = list(self._working_queue.keys())
@@ -255,8 +262,7 @@ def __next__(self) -> Job:
         return job
 
     def _pulse(self) -> None:
-        # TODO: document this better.
-        """Used internally; manages the queue system operations."""
+        # Used internally; manages the queue system operations.
 
         with self._lock:
             try:
@@ -359,7 +365,7 @@ def _pulse(self) -> None:
                                         self._start_job(next_job)
 
                     while (
-                        len(self._waiting_groups[self.DEFAULT_GROUP]) > 0
+                        self._waiting_groups.get(self.DEFAULT_GROUP)
                         and self.max_concurrent - self._count_working() > 0
                     ):
                         job = heappop(self._waiting_groups[self.DEFAULT_GROUP])
@@ -377,19 +383,31 @@ def _pulse(self) -> None:
                 )
 
     def _count_waiting(self) -> int:
-        """Get the number of pending jobs."""
+        """
+        Returns:
+            The number of pending jobs.
+        """
         return sum(len(v) for _, v in self._waiting_groups.items())
 
     def _count_working(self) -> int:
-        """Get the number of running jobs."""
+        """
+        Returns:
+            The number of running jobs.
+        """
         return len(self._working_queue)
 
     def _count_finished(self) -> int:
-        """Get the number of completed jobs."""
+        """
+        Returns:
+            The number of completed jobs.
+        """
         return len(self._finished_queue)
 
     def _count_remaining(self) -> int:
-        """Get the number of unfinished jobs (i.e., waiting + working)."""
+        """
+        Returns:
+            The number of unfinished jobs (i.e., waiting + working).
+        """
         return self.size(waiting=True, working=True)
 
     def _sizes(
@@ -461,6 +479,9 @@ def size(
             working: include working jobs.
             finished: include finished jobs.
 
+        Returns:
+            ...
+
         Examples:
             >>> from ppqueue import Queue
             ...
@@ -483,15 +504,27 @@ def is_idle(self) -> bool:
         return self._count_waiting() == 0 and self._count_working() == 0
 
     def is_busy(self) -> bool:
-        """True if max concurrent limit is reached or if there are waiting jobs."""
+        """True if max concurrent limit is reached or if there are waiting jobs.
+
+        Returns:
+            ...
+        """
         return self._count_waiting() > 0 or self.max_concurrent <= self._count_working()
 
     def is_empty(self) -> bool:
-        """True if there are no jobs in the queue system."""
+        """True if there are no jobs in the queue system.
+
+        Returns:
+            ...
+        """
         return self.size() == 0
 
     def is_full(self) -> bool:
-        """True if the number of jobs in the queue system is equal to max_size."""
+        """True if the number of jobs in the queue system is equal to max_size.
+
+        Returns:
+            ...
+        """
         return 0 < self._max_size <= self.size()
 
     def join(self, *args, **kwargs) -> int:
@@ -512,6 +545,10 @@ def wait(
             timeout: seconds to wait before raising `TimeoutError` (default=0, indefinitely).
             poll_ms: milliseconds to pause between checks (default=100).
             show_progress: if True, present a progress bar.
+
+        Returns:
+            If `n <= 0`, returns the count of unfinished jobs.
+            Else, returns the count of finished jobs.
         """
         if poll_ms is None or poll_ms <= 0:
             poll_ms = self._pulse_freq_ms
@@ -573,7 +610,7 @@ def _job_wrapper(
         *args: Any,
         **kwargs: Any,
     ) -> tuple[str | None, str | None, int, float]:
-        """Used internally to wrap data, capture output and any exception."""
+        # Used internally to wrap data, capture output and any exception.
         stdout: str | None = None
         stderr: str | None = None
         exitcode: int
@@ -608,9 +645,11 @@ def _start_job(self, job: Job, /) -> None:
     def _submit(self, job: Job, /) -> int:
         """Submits a job into the ppqueue.Queue system.
 
-        Throws an exception if:
-            1. the Queue uses a Thread job_runner and this data has a timeout (can't terminate Threads),
-            2. the Queue max_size will be exceeded after adding this job.
+        Args:
+            job: ...
+
+        Raises:
+            OverflowError: if max_size will be exceeded after adding this job.
 
         Returns:
             The number of jobs submitted to the queue.
@@ -661,14 +700,18 @@ def enqueue(
         """Adds a job to the queue.
 
         Args:
-            args:
-            kwargs:
-            name:
-            priority:
-            group:
-            timeout:
-            suppress_errors:
-            skip_on_group_error:
+            fun: ...
+            args: ...
+            kwargs: ...
+            name: ...
+            priority: ...
+            group: ...
+            timeout: ...
+            suppress_errors: ...
+            skip_on_group_error: ...
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -700,7 +743,16 @@ def enqueue(
         return self._submit(job)
 
     def put(self, *args, **kwargs) -> int:
-        """Alias for `enqueue`. Adds a job to the queue.
+        """Alias for `enqueue`.
+
+        Adds a job to the queue.
+
+        Args:
+            *args: ...
+            **kwargs: ...
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -732,10 +784,15 @@ def map(
         """Submits many jobs to the queue -- one for each item in the iterable. Waits for all to finish, then returns the results.
 
         Args:
-            fun:
-            iterable:
-            timeout:
-            show_progress:
+            fun: ...
+            iterable: ...
+            *args: ...
+            timeout: ...
+            show_progress: ...
+            **kwargs: ...
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -771,10 +828,15 @@ def starmap(
         """Submits many jobs to the queue -- one for each sequence in the iterable. Waits for all to finish, then returns the results.
 
         Args:
-            fun:
-            iterable:
-            timeout:
-            show_progress:
+            fun: ...
+            iterable: ...
+            *args: static arguments passed to the function.
+            timeout: ...
+            show_progress: ...
+            **kwargs: static keyword-arguments passed to the function.
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -814,10 +876,15 @@ def starmapkw(
         """Submits many jobs to the queue -- one for each dictionary in the iterable. Waits for all to finish, then returns the results.
 
         Args:
-            fun:
-            iterable:
-            timeout:
-            show_progress:
+            fun: ...
+            iterable: ...
+            *args: static arguments passed to the function.
+            timeout: ...
+            show_progress: ...
+            **kwargs: static keyword-arguments passed to the function.
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -852,12 +919,15 @@ def dequeue(
         _peek: bool = False,
         **kwargs: Any,
     ) -> Job | None:
-        """Removes and returns the job with the highest priority from the queue.
+        """Removes and returns the finished job with the highest priority from the queue.
 
         Args:
-            wait:
+            wait: if no jobs are finished, wait for one.
             **kwargs: passed to `Queue.wait`
 
+        Returns:
+            ...
+
         Examples:
             >>> from ppqueue import Queue
             ...
@@ -891,7 +961,14 @@ def dequeue(
         return job
 
     def pop(self, *args: Any, **kwargs: Any) -> Job | None:
-        """Alias for `dequeue`. Removes and returns the job with the highest priority from the queue.
+        """Alias for `dequeue`.
+
+        Args:
+            *args: ...
+            **kwargs: ...
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -911,11 +988,16 @@ def pop(self, *args: Any, **kwargs: Any) -> Job | None:
         return self.dequeue(*args, **kwargs)
 
     def peek(self, *args: Any, **kwargs: Any) -> Job | None:
-        """Returns the job with the highest priority from the queue. Similar to `enqueue` / `pop`, but the job remains in the queue.
+        """Returns the job with the highest priority from the queue.
+
+        Similar to `dequeue` / `pop`, but the job remains in the queue.
 
         Args:
-            *args:
-            **kwargs:
+            *args: ...
+            **kwargs: ...
+
+        Returns:
+            ...
 
         Examples:
             >>> from ppqueue import Queue
@@ -948,6 +1030,9 @@ def collect(self, n: int = 0, wait: bool = False, **kwargs: Any) -> list[Job]:
             wait: If True, block until this many jobs are finished. Else, immediately return all finished.
             **kwargs: kwargs given to `Queue.wait`.
 
+        Returns:
+            a list of `Job` instances.
+
         Examples:
             >>> from ppqueue import Queue
             ...
diff --git a/src/ppqueue/utils.py b/src/ppqueue/utils.py
index bb1e6c6..02fd049 100644
--- a/src/ppqueue/utils.py
+++ b/src/ppqueue/utils.py
@@ -2,19 +2,10 @@
 
 import logging
 import os
-from typing import List, Optional, TypeVar, Union
+from typing import List, Optional, TypeVar
 
 
 def get_logger(name: str, level: Optional[int] = None) -> logging.Logger:
-    """get or create a logger.
-
-    Args:
-        name (str)
-        level (Optional[int]): Defaults to logging.DEBUG.
-
-    Returns:
-        logging.Logger
-    """
     logger = logging.getLogger(name)
 
     logger.setLevel(logging.INFO if level is None else level)
@@ -33,18 +24,17 @@ def is_windows_os() -> bool:
     return os.name == "nt"
 
 
-def compare(num1: Union[int, float], num2: Union[int, float]) -> int:
-    """compare two numbers.
+def compare(num1: int | float, num2: int | float) -> int:
+    """Compare two numbers.
 
     Args:
-        num1 (Union[int, float]): the reference number.
-        num2 (Union[int, float]): the comparison number.
+        num1: the reference number.
+        num2: the comparison number.
 
     Returns:
-        int:
-            * 0  if num1 == num2
-            * 1  if num1 > num2
-            * -1 if num1 < num2
+        0  if num1 == num2
+        1  if num1 > num2
+        -1 if num1 < num2
     """
     if num1 == num2:
         return 0
@@ -62,21 +52,20 @@ def compare(num1: Union[int, float], num2: Union[int, float]) -> int:
 
 
 def compare_by(object1: object, object2: object, by: List[str], _state: int = 0) -> int:
-    """compare two objects by a list of attributes.
-    attributes are compared iteratively and the comparison will
+    """Compare two objects by a list of attributes.
+
+    Attributes are compared iteratively and the comparison will
     short-circuit when/if the objects are determined unequal.
 
     Args:
-        _state:
-        object1 (object): the reference object.
-        object2 (object): the comparison object.
-        by (List[str]): list of attributes to compare.
+        object1: the reference object.
+        object2: the comparison object.
+        by: list of attributes to compare.
 
     Returns:
-        int:
-            * 0  if object1 == object2
-            * 1  if object1 > object2
-            * -1 if object1 < object2
+        0  if object1 == object2
+        1  if object1 > object2
+        -1 if object1 < object2
     """
     if _state and _state >= len(by):
         # if we've compared all attributes,