diff --git a/src/_pytask/pluginmanager.py b/src/_pytask/pluginmanager.py
index 4674c28b..8ebcab35 100644
--- a/src/_pytask/pluginmanager.py
+++ b/src/_pytask/pluginmanager.py
@@ -58,6 +58,7 @@ def pytask_add_hooks(pm: PluginManager) -> None:
         "_pytask.skipping",
         "_pytask.task",
         "_pytask.warnings",
+        "_pytask.vscode",
     )
     register_hook_impls_from_modules(pm, builtin_hook_impl_modules)
 
diff --git a/src/_pytask/vscode.py b/src/_pytask/vscode.py
new file mode 100644
index 00000000..30552d69
--- /dev/null
+++ b/src/_pytask/vscode.py
@@ -0,0 +1,124 @@
+"""Contains Code for VSCode Logging."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from threading import Thread
+from typing import TYPE_CHECKING
+from typing import Any
+from urllib.error import URLError
+from urllib.request import urlopen
+
+from _pytask.config import hookimpl
+from _pytask.console import console
+from _pytask.console import render_to_string
+from _pytask.nodes import PTaskWithPath
+from _pytask.outcomes import CollectionOutcome
+from _pytask.outcomes import TaskOutcome
+from _pytask.traceback import Traceback
+
+if TYPE_CHECKING:
+    from _pytask.node_protocols import PTask
+    from _pytask.reports import CollectionReport
+    from _pytask.reports import ExecutionReport
+    from _pytask.session import Session
+
+
+TIMEOUT = 0.00001
+DEFAULT_VSCODE_PORT = 6000
+
+
+def send_logging_info(url: str, data: dict[str, Any], timeout: float) -> None:
+    """Send logging information to the provided port.
+
+    A response from the server is not needed, therefore a very low timeout is used to
+    essentially "fire-and-forget" the HTTP request. Because the HTTP protocol expects a
+    response, the urllib will throw an URLError or (rarely) a TimeoutError, which will
+    be suppressed.
+
+    """
+    response = json.dumps(data).encode()
+    with contextlib.suppress(URLError, TimeoutError):
+        urlopen(url=url, data=response, timeout=timeout)  # noqa: S310
+
+
+def validate_and_return_port(port: str) -> int:
+    """Validate the port number and return it as an integer.
+
+    The value of the environment variable is used as a direct input for the url, that
+    the logging info is sent to. To avoid security concerns the value is checked to
+    contain a valid port number and not an arbitrary string that could modify the url.
+
+    If the port cannot be converted to an integer, a ValueError is raised.
+
+    """
+    try:
+        out = int(port)
+    except ValueError as e:
+        msg = (
+            "The value provided in the environment variable PYTASK_VSCODE must be an "
+            f"integer, got {port} instead."
+        )
+        raise ValueError(msg) from e
+    return out
+
+
+@hookimpl(tryfirst=True)
+def pytask_collect_log(
+    session: Session, reports: list[CollectionReport], tasks: list[PTask]
+) -> None:
+    """Start threads to send logging information for collected tasks."""
+    if (
+        os.environ.get("PYTASK_VSCODE") is not None
+        and session.config["command"] == "collect"
+    ):
+        port = validate_and_return_port(os.environ["PYTASK_VSCODE"])
+
+        exitcode = "OK"
+        for report in reports:
+            if report.outcome == CollectionOutcome.FAIL:
+                exitcode = "COLLECTION_FAILED"
+
+        result = []
+        for task in tasks:
+            path = str(task.path) if isinstance(task, PTaskWithPath) else ""
+            result.append({"name": task.name, "path": path})
+
+        thread = Thread(
+            target=send_logging_info,
+            kwargs={
+                "url": f"http://localhost:{port}/pytask/collect",
+                "data": {"exitcode": exitcode, "tasks": result},
+                "timeout": TIMEOUT,
+            },
+        )
+        thread.start()
+
+
+@hookimpl(tryfirst=True)
+def pytask_execute_task_log_end(
+    session: Session,  # noqa: ARG001
+    report: ExecutionReport,
+) -> None:
+    """Start threads to send logging information for executed tasks."""
+    if os.environ.get("PYTASK_VSCODE") is not None:
+        port = validate_and_return_port(os.environ["PYTASK_VSCODE"])
+
+        result = {
+            "name": report.task.name,
+            "outcome": str(report.outcome),
+        }
+        if report.outcome == TaskOutcome.FAIL and report.exc_info is not None:
+            result["exc_info"] = render_to_string(Traceback(report.exc_info), console)
+
+        thread = Thread(
+            target=send_logging_info,
+            kwargs={
+                "url": f"http://localhost:{port}/pytask/run",
+                "data": result,
+                "timeout": TIMEOUT,
+            },
+        )
+        thread.start()
diff --git a/tests/test_vscode.py b/tests/test_vscode.py
new file mode 100644
index 00000000..1f2e5dec
--- /dev/null
+++ b/tests/test_vscode.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import json
+import os
+import textwrap
+from unittest.mock import MagicMock
+
+import pytest
+from _pytask.vscode import send_logging_info
+from _pytask.vscode import validate_and_return_port
+from pytask import ExitCode
+from pytask import cli
+
+
+@pytest.mark.unit()
+def test_validate_and_return_port_valid_port():
+    assert validate_and_return_port("6000") == 6000
+
+
+@pytest.mark.unit()
+def test_validate_and_return_port_invalid_port():
+    with pytest.raises(
+        ValueError,
+        match="The value provided in the environment variable "
+        "PYTASK_VSCODE must be an integer, got not_an_integer instead.",
+    ):
+        validate_and_return_port("not_an_integer")
+
+
+@pytest.mark.unit()
+def test_send_logging_info(monkeypatch):
+    mock_urlopen = MagicMock()
+    monkeypatch.setattr("_pytask.vscode.urlopen", mock_urlopen)
+
+    url = "http://localhost:6000/pytask/run"
+    data = {"test": "test"}
+    timeout = 0.00001
+    response = json.dumps(data).encode()
+
+    send_logging_info(url, data, timeout)
+    mock_urlopen.assert_called_with(url=url, data=response, timeout=timeout)
+
+
+@pytest.mark.end_to_end()
+def test_vscode_collect_failed(runner, tmp_path, monkeypatch):
+    mock_urlopen = MagicMock()
+    monkeypatch.setattr("_pytask.vscode.urlopen", mock_urlopen)
+    source = """
+    raise Exception
+    """
+    os.environ["PYTASK_VSCODE"] = "6000"
+    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["collect", tmp_path.as_posix()])
+    assert result.exit_code == ExitCode.COLLECTION_FAILED
+    mock_urlopen.assert_called_with(
+        url="http://localhost:6000/pytask/collect",
+        data=b'{"exitcode": "COLLECTION_FAILED", "tasks": []}',
+        timeout=0.00001,
+    )
+
+
+@pytest.mark.end_to_end()
+def test_vscode_collect(runner, tmp_path):
+    source = """
+    def task_example():
+        return
+    """
+    os.environ["PYTASK_VSCODE"] = "6000"
+    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["collect", tmp_path.as_posix()])
+    assert result.exit_code == ExitCode.OK
+
+
+@pytest.mark.end_to_end()
+def test_vscode_build(runner, tmp_path, monkeypatch):
+    mock_urlopen = MagicMock()
+    monkeypatch.setattr("_pytask.vscode.urlopen", mock_urlopen)
+    source = """
+    def task_example():
+        return
+    def task_raises():
+        raise Exception
+    """
+    os.environ["PYTASK_VSCODE"] = "6000"
+    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, [tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.FAILED
+    assert mock_urlopen.call_count == 2