diff --git a/docs/source/tracking.mdx b/docs/source/tracking.mdx
index 256e2848b..959317887 100644
--- a/docs/source/tracking.mdx
+++ b/docs/source/tracking.mdx
@@ -106,7 +106,7 @@ from typing import Optional
 import wandb
 
 
-class WandBTracker(GeneralTracker):
+class MyCustomTracker(GeneralTracker):
     def __init__(self, run_name: str):
         self.run_name = run_name
         wandb.init(self.run_name)
@@ -118,6 +118,21 @@ class WandBTracker(GeneralTracker):
         wandb.log(values, step=step)
 ```
 
+When you are ready to build your `Accelerator` object, pass in an **instance** of your tracker to [`~Accelerator.log_with`] to have it automatically
+be used with the API:
+
+```python
+tracker = MyCustomTracker("some_run_name")
+accelerator = Accelerate(log_with=tracker)
+```
+
+These also can be mixed with existing trackers, including with `"all"`:
+
+```python
+tracker = MyCustomTracker("some_run_name")
+accelerator = Accelerate(log_with=[tracker, "all"])
+```
+
 ## When a wrapper cannot work
 
 If a library has an API that does not follow a strict `.log` with an overall dictionary such as Neptune.AI, logging can be done manually under an `if accelerator.is_main_process` statement:
diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py
index 67c981de3..6e0742e02 100644
--- a/src/accelerate/accelerator.py
+++ b/src/accelerate/accelerator.py
@@ -29,7 +29,7 @@
 from .optimizer import AcceleratedOptimizer
 from .scheduler import AcceleratedScheduler
 from .state import AcceleratorState, DistributedType, is_deepspeed_available
-from .tracking import CometMLTracker, TensorBoardTracker, WandBTracker, get_available_trackers
+from .tracking import CometMLTracker, GeneralTracker, TensorBoardTracker, WandBTracker, get_available_trackers
 from .utils import (
     DeepSpeedPlugin,
     LoggerType,
@@ -94,15 +94,15 @@ class Accelerator:
               dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.
 
             Will default to `["torch"]` for PyTorch versions <=1.5.1 and `["generator"]` for PyTorch versions >= 1.6.
-        log_with (list of `str` or [`~utils.LoggerType`], *optional*):
+        log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):
             A list of loggers to be setup for experiment tracking. Should be one or several of:
 
             - `"all"`
             - `"tensorboard"`
             - `"wandb"`
             - `"comet_ml"`
-
-            If `"all`" is selected, will pick up all available trackers in the environment and intialize them.
+            If `"all`" is selected, will pick up all available trackers in the environment and intialize them. Can also
+            accept implementations of `GeneralTracker` for custom trackers, and can be combined with `"all"`.
         logging_dir (`str`, `os.PathLike`, *optional*):
             A path to a directory for storing logs of locally-compatible loggers.
         dispatch_batches (`bool`, *optional*):
@@ -131,26 +131,32 @@ def __init__(
         cpu: bool = False,
         deepspeed_plugin: DeepSpeedPlugin = None,
         rng_types: Optional[List[Union[str, RNGType]]] = None,
-        log_with: Optional[List[Union[str, LoggerType]]] = None,
+        log_with: Optional[List[Union[str, LoggerType, GeneralTracker]]] = None,
         logging_dir: Optional[Union[str, os.PathLike]] = "",
         dispatch_batches: Optional[bool] = None,
         step_scheduler_with_optimizer: bool = True,
         kwargs_handlers: Optional[List[KwargsHandler]] = None,
     ):
+        loggers = []
         if log_with is not None:
-            if not isinstance(log_with, list):
+            if not isinstance(log_with, (list, tuple)):
                 log_with = [log_with]
+                logger.debug(f"{log_with}")
             if "all" in log_with or LoggerType.ALL in log_with:
-                log_with = get_available_trackers()
+                loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers()
             else:
-                for i, log_type in enumerate(log_with):
-                    if log_type not in LoggerType:
+                for log_type in log_with:
+                    if log_type not in LoggerType and not issubclass(type(log_type), GeneralTracker):
                         raise ValueError(
                             f"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}"
                         )
-                    log_with[i] = LoggerType(log_type)
-                log_with = list(set(log_with))
-        self.log_with = log_with
+                    if issubclass(type(log_type), GeneralTracker):
+                        loggers.append(log_type)
+                    else:
+                        log_type = LoggerType(log_type)
+                        if log_type not in loggers:
+                            loggers.append(log_type)
+        self.log_with = loggers
         self.logging_dir = logging_dir
 
         if mixed_precision is not None:
@@ -631,7 +637,10 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):
         """
         self.trackers = []
         for tracker in self.log_with:
-            if str(tracker).lower() == "tensorboard" and is_tensorboard_available():
+            if issubclass(type(tracker), GeneralTracker):
+                # Custom trackers are already initialized
+                self.trackers.append(tracker)
+            elif str(tracker).lower() == "tensorboard" and is_tensorboard_available():
                 self.trackers.append(TensorBoardTracker(project_name, self.logging_dir))
             elif str(tracker).lower() == "wandb" and is_wandb_available():
                 self.trackers.append(WandBTracker(project_name))
diff --git a/tests/test_tracking.py b/tests/test_tracking.py
index b1f66b1ae..62c423ef7 100644
--- a/tests/test_tracking.py
+++ b/tests/test_tracking.py
@@ -12,17 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import csv
 import logging
 import os
 import re
 import tempfile
 import unittest
 from pathlib import Path
+from typing import Optional
 from unittest import mock
 
 # We use TF to parse the logs
 from accelerate import Accelerator
 from accelerate.test_utils.testing import MockingTestCase, TempDirTestCase, require_tensorflow
+from accelerate.tracking import GeneralTracker
 from accelerate.utils import is_tensorflow_available
 
 
@@ -157,3 +160,77 @@ def test_log(self):
         self.assertEqual(self.get_value_from_log("iteration", cleaned_log), "1")
         self.assertEqual(self.get_value_from_log("my_text", cleaned_log), "some_value")
         self.assertEqual(self.get_value_from_log("_step", cleaned_log), "0")
+
+
+class MyCustomTracker(GeneralTracker):
+    "Basic tracker that writes to a csv for testing"
+    _col_names = [
+        "total_loss",
+        "iteration",
+        "my_text",
+        "learning_rate",
+        "num_iterations",
+        "some_boolean",
+        "some_string",
+    ]
+
+    def __init__(self, dir: str):
+        self.f = open(f"{dir}/log.csv", "w+")
+        self.writer = csv.DictWriter(self.f, fieldnames=self._col_names)
+        self.writer.writeheader()
+
+    def store_init_configuration(self, values: dict):
+        logger.info("Call init")
+        self.writer.writerow(values)
+
+    def log(self, values: dict, step: Optional[int]):
+        logger.info("Call log")
+        self.writer.writerow(values)
+
+    def finish(self):
+        self.f.close()
+
+
+class CustomTrackerTestCase(unittest.TestCase):
+    def test_init_trackers(self):
+        with tempfile.TemporaryDirectory() as d:
+            tracker = MyCustomTracker(d)
+            accelerator = Accelerator(log_with=tracker)
+            config = {"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"}
+            accelerator.init_trackers("Some name", config)
+            accelerator.end_training()
+            with open(f"{d}/log.csv", "r") as f:
+                data = csv.DictReader(f)
+                data = next(data)
+                truth = {
+                    "total_loss": "",
+                    "iteration": "",
+                    "my_text": "",
+                    "learning_rate": "0.01",
+                    "num_iterations": "12",
+                    "some_boolean": "False",
+                    "some_string": "some_value",
+                }
+                self.assertDictEqual(data, truth)
+
+    def test_log(self):
+        with tempfile.TemporaryDirectory() as d:
+            tracker = MyCustomTracker(d)
+            accelerator = Accelerator(log_with=tracker)
+            accelerator.init_trackers("Some name")
+            values = {"total_loss": 0.1, "iteration": 1, "my_text": "some_value"}
+            accelerator.log(values, step=0)
+            accelerator.end_training()
+            with open(f"{d}/log.csv", "r") as f:
+                data = csv.DictReader(f)
+                data = next(data)
+                truth = {
+                    "total_loss": "0.1",
+                    "iteration": "1",
+                    "my_text": "some_value",
+                    "learning_rate": "",
+                    "num_iterations": "",
+                    "some_boolean": "",
+                    "some_string": "",
+                }
+                self.assertDictEqual(data, truth)


Review comments: body: ```suggestion
                # Custom trackers are already initialized
```
diff_hunk: @@ -631,7 +637,10 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):
         """
         self.trackers = []
         for tracker in self.log_with:
-            if str(tracker).lower() == "tensorboard" and is_tensorboard_available():
+            if issubclass(type(tracker), GeneralTracker):
+                # Custom tracker that they already initalized

Discussion: body: _The documentation is not available anymore as the PR was closed or merged._