diff --git a/simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClient.cpp b/simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClient.cpp
index 007c038064..dfa54d29f4 100644
--- a/simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClient.cpp
+++ b/simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClient.cpp
@@ -5,16 +5,19 @@
 #include "HALSimWSClient.h"
 
 #include <WSProviderContainer.h>
+#include <WSProvider_AddressableLED.h>
 #include <WSProvider_Analog.h>
 #include <WSProvider_BuiltInAccelerometer.h>
 #include <WSProvider_DIO.h>
 #include <WSProvider_DriverStation.h>
 #include <WSProvider_Encoder.h>
 #include <WSProvider_Joystick.h>
+#include <WSProvider_PCM.h>
 #include <WSProvider_PWM.h>
 #include <WSProvider_Relay.h>
 #include <WSProvider_RoboRIO.h>
 #include <WSProvider_SimDevice.h>
+#include <WSProvider_Solenoid.h>
 #include <WSProvider_dPWM.h>
 #include <wpi/EventLoopRunner.h>
 
@@ -34,6 +37,7 @@ bool HALSimWSClient::Initialize() {
       providers.Add(key, provider);
     };
 
+    HALSimWSProviderAddressableLED::Initialize(registerFunc);
     HALSimWSProviderAnalogIn::Initialize(registerFunc);
     HALSimWSProviderAnalogOut::Initialize(registerFunc);
     HALSimWSProviderBuiltInAccelerometer::Initialize(registerFunc);
@@ -42,9 +46,11 @@ bool HALSimWSClient::Initialize() {
     HALSimWSProviderDriverStation::Initialize(registerFunc);
     HALSimWSProviderEncoder::Initialize(registerFunc);
     HALSimWSProviderJoystick::Initialize(registerFunc);
+    HALSimWSProviderPCM::Initialize(registerFunc);
     HALSimWSProviderPWM::Initialize(registerFunc);
     HALSimWSProviderRelay::Initialize(registerFunc);
     HALSimWSProviderRoboRIO::Initialize(registerFunc);
+    HALSimWSProviderSolenoid::Initialize(registerFunc);
 
     simDevices.Initialize(loop);
 
diff --git a/simulation/halsim_ws_core/doc/hardware_ws_api.md b/simulation/halsim_ws_core/doc/hardware_ws_api.md
index 243c868d91..b2b40fc8b4 100644
--- a/simulation/halsim_ws_core/doc/hardware_ws_api.md
+++ b/simulation/halsim_ws_core/doc/hardware_ws_api.md
@@ -87,6 +87,7 @@ The “hardware“ (which might be a full-fledged 3D simulation engine, a physic
 | [``"Joystick"``][]      | Joystick data              | Joystick number           |
 | [``"PWM"``][]           | PWM output                 | Port index, e.g. "1", "2" |
 | [``"Relay"``][]         | Relay output               | Port index, e.g. "1", "2" |
+| [``"Solenoid"``][]      | Solenoid output            | Module +Port index, e.g. "0,1", "2,5" |
 
 #### Accelerometer ("Accel")
 
@@ -237,6 +238,17 @@ PWMs may be used to control either speed controllers or servos.  Typically only
 | ``"<fwd"``      | Boolean | True if forward direction is enabled                           |
 | ``"<rev"``      | Boolean | True if reverse direction is enabled                           |
 
+#### Solenoid Output ("Solenoid")
+
+[``"Solenoid"``]:#solenoid-output-solenoid
+
+Solenoids are used to control pneumatic pistons
+
+| Data Key        | Type    | Description                                     |
+| --------------- | ------- | ----------------------------------------------- |
+| ``"<init"``     | Boolean | If Solenoid is initialized in the robot program |
+| ``"<output"``   | Boolean | The state of the solenoid                       |
+
 ### CAN Messages
 
 CAN messages all use a device value of ``"DeviceType[Number]"``, where the DeviceType is the vendor-specific CAN device type (motor controller class) name and Number is the CAN device number (the user-visible number passed to the device constructor).
diff --git a/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_AddressableLED.cpp b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_AddressableLED.cpp
new file mode 100644
index 0000000000..4cac7f577f
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_AddressableLED.cpp
@@ -0,0 +1,78 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "WSProvider_AddressableLED.h"
+
+#include <hal/Ports.h>
+#include <hal/simulation/AddressableLEDData.h>
+
+#define REGISTER(halsim, jsonid, ctype, haltype)                          \
+  HALSIM_RegisterAddressableLED##halsim##Callback(                        \
+      m_channel,                                                          \
+      [](const char* name, void* param, const struct HAL_Value* value) {  \
+        static_cast<HALSimWSProviderAddressableLED*>(param)               \
+            ->ProcessHalCallback(                                         \
+                {{jsonid, static_cast<ctype>(value->data.v_##haltype)}}); \
+      },                                                                  \
+      this, true)
+namespace wpilibws {
+void HALSimWSProviderAddressableLED::Initialize(
+    WSRegisterFunc webRegisterFunc) {
+  CreateProviders<HALSimWSProviderAddressableLED>(
+      "AddressableLED", HAL_GetNumAddressableLEDs(), webRegisterFunc);
+}
+
+HALSimWSProviderAddressableLED::~HALSimWSProviderAddressableLED() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderAddressableLED::RegisterCallbacks() {
+  m_initCbKey = REGISTER(Initialized, "<init", bool, boolean);
+  m_outputPortCbKey = REGISTER(OutputPort, "<output_port", int32_t, int);
+  m_lengthCbKey = REGISTER(Length, "<length", int32_t, int);
+  m_runningCbKey = REGISTER(Running, "<running", bool, boolean);
+
+  m_dataCbKey = HALSIM_RegisterAddressableLEDDataCallback(
+      0,
+      [](const char* name, void* param, const unsigned char* buffer,
+         unsigned int count) {
+        auto provider = static_cast<HALSimWSProviderAddressableLED*>(param);
+
+        size_t numLeds = count / sizeof(HAL_AddressableLEDData);
+        const HAL_AddressableLEDData* data =
+            reinterpret_cast<const HAL_AddressableLEDData*>(buffer);
+
+        std::vector<wpi::json> jsonData;
+
+        for (size_t i = 0; i < numLeds; ++i) {
+          jsonData.push_back(
+              {{"r", data[i].r}, {"g", data[i].g}, {"b", data[i].b}});
+        }
+
+        wpi::json payload;
+        payload[">data"] = jsonData;
+
+        provider->ProcessHalCallback(payload);
+      },
+      this);
+}
+
+void HALSimWSProviderAddressableLED::CancelCallbacks() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderAddressableLED::DoCancelCallbacks() {
+  HALSIM_CancelAddressableLEDInitializedCallback(m_channel, m_initCbKey);
+  HALSIM_CancelAddressableLEDOutputPortCallback(m_channel, m_outputPortCbKey);
+  HALSIM_CancelAddressableLEDLengthCallback(m_channel, m_lengthCbKey);
+  HALSIM_CancelAddressableLEDRunningCallback(m_channel, m_runningCbKey);
+  HALSIM_CancelAddressableLEDDataCallback(m_channel, m_dataCbKey);
+
+  m_initCbKey = 0;
+  m_outputPortCbKey = 0;
+  m_lengthCbKey = 0;
+  m_runningCbKey = 0;
+  m_dataCbKey = 0;
+}
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_PCM.cpp b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_PCM.cpp
new file mode 100644
index 0000000000..1b129595d2
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_PCM.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "WSProvider_PCM.h"
+
+#include <hal/Ports.h>
+#include <hal/simulation/PCMData.h>
+
+#define REGISTER_PCM(halsim, jsonid, ctype, haltype)                     \
+  HALSIM_RegisterPCM##halsim##Callback(                                  \
+      m_channel,                                                         \
+      [](const char* name, void* param, const struct HAL_Value* value) { \
+        static_cast<HALSimWSProviderPCM*>(param)->ProcessHalCallback(    \
+            {{jsonid, static_cast<ctype>(value->data.v_##haltype)}});    \
+      },                                                                 \
+      this, true)
+namespace wpilibws {
+void HALSimWSProviderPCM::Initialize(WSRegisterFunc webRegisterFunc) {
+  CreateProviders<HALSimWSProviderPCM>("PCM", HAL_GetNumPCMModules(),
+                                       webRegisterFunc);
+}
+
+HALSimWSProviderPCM::~HALSimWSProviderPCM() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderPCM::RegisterCallbacks() {
+  m_initCbKey = REGISTER_PCM(CompressorInitialized, "<init", bool, boolean);
+  m_onCbKey = REGISTER_PCM(CompressorInitialized, ">on", bool, boolean);
+  m_closedLoopCbKey =
+      REGISTER_PCM(ClosedLoopEnabled, "<closed_loop", bool, boolean);
+  m_pressureSwitchCbKey =
+      REGISTER_PCM(PressureSwitch, ">pressure_switch", bool, boolean);
+  m_currentCbKey = REGISTER_PCM(CompressorCurrent, ">current", double, double);
+}
+
+void HALSimWSProviderPCM::CancelCallbacks() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderPCM::DoCancelCallbacks() {
+  HALSIM_CancelPCMCompressorInitializedCallback(m_channel, m_initCbKey);
+  HALSIM_CancelPCMCompressorOnCallback(m_channel, m_onCbKey);
+  HALSIM_CancelPCMClosedLoopEnabledCallback(m_channel, m_closedLoopCbKey);
+  HALSIM_CancelPCMPressureSwitchCallback(m_channel, m_pressureSwitchCbKey);
+  HALSIM_CancelPCMCompressorCurrentCallback(m_channel, m_currentCbKey);
+
+  m_initCbKey = 0;
+  m_onCbKey = 0;
+  m_closedLoopCbKey = 0;
+  m_pressureSwitchCbKey = 0;
+  m_currentCbKey = 0;
+}
+
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_Solenoid.cpp b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_Solenoid.cpp
new file mode 100644
index 0000000000..4c77d4bcd1
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/cpp/WSProvider_Solenoid.cpp
@@ -0,0 +1,67 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "WSProvider_Solenoid.h"
+
+#include <hal/Ports.h>
+#include <hal/simulation/PCMData.h>
+
+#define REGISTER_SOLENOID(halsim, jsonid, ctype, haltype)                  \
+  HALSIM_RegisterPCMSolenoid##halsim##Callback(                            \
+      m_pcmIndex, m_solenoidIndex,                                         \
+      [](const char* name, void* param, const struct HAL_Value* value) {   \
+        static_cast<HALSimWSProviderSolenoid*>(param)->ProcessHalCallback( \
+            {{jsonid, static_cast<ctype>(value->data.v_##haltype)}});      \
+      },                                                                   \
+      this, true)
+
+namespace wpilibws {
+void HALSimWSProviderSolenoid::Initialize(WSRegisterFunc webRegisterFunc) {
+  for (int32_t pcmIndex = 0; pcmIndex < HAL_GetNumPCMModules(); ++pcmIndex) {
+    for (int32_t solenoidIndex = 0;
+         solenoidIndex < HAL_GetNumSolenoidChannels(); ++solenoidIndex) {
+      auto key =
+          ("Solenoid/" + wpi::Twine(pcmIndex) + "," + wpi::Twine(solenoidIndex))
+              .str();
+      auto ptr = std::make_unique<HALSimWSProviderSolenoid>(
+          pcmIndex, solenoidIndex, key, "Solenoid");
+      webRegisterFunc(key, std::move(ptr));
+    }
+  }
+}
+
+HALSimWSProviderSolenoid::HALSimWSProviderSolenoid(int32_t pcmChannel,
+                                                   int32_t solenoidChannel,
+                                                   const std::string& key,
+                                                   const std::string& type)
+    : HALSimWSHalProvider(key, type),
+      m_pcmIndex(pcmChannel),
+      m_solenoidIndex(solenoidChannel) {
+  m_deviceId =
+      std::to_string(m_pcmIndex) + "," + std::to_string(solenoidChannel);
+}
+
+HALSimWSProviderSolenoid::~HALSimWSProviderSolenoid() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderSolenoid::RegisterCallbacks() {
+  m_initCbKey = REGISTER_SOLENOID(Initialized, "<init", bool, boolean);
+  m_outputCbKey = REGISTER_SOLENOID(Output, "<output", bool, boolean);
+}
+
+void HALSimWSProviderSolenoid::CancelCallbacks() {
+  DoCancelCallbacks();
+}
+
+void HALSimWSProviderSolenoid::DoCancelCallbacks() {
+  HALSIM_CancelPCMSolenoidInitializedCallback(m_pcmIndex, m_solenoidIndex,
+                                              m_initCbKey);
+  HALSIM_CancelPCMSolenoidOutputCallback(m_pcmIndex, m_solenoidIndex,
+                                         m_outputCbKey);
+
+  m_initCbKey = 0;
+  m_outputCbKey = 0;
+}
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/include/WSProvider_AddressableLED.h b/simulation/halsim_ws_core/src/main/native/include/WSProvider_AddressableLED.h
new file mode 100644
index 0000000000..48e6e9fe62
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/include/WSProvider_AddressableLED.h
@@ -0,0 +1,29 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include "WSHalProviders.h"
+
+namespace wpilibws {
+class HALSimWSProviderAddressableLED : public HALSimWSHalChanProvider {
+ public:
+  static void Initialize(WSRegisterFunc webRegisterFunc);
+
+  using HALSimWSHalChanProvider::HALSimWSHalChanProvider;
+  ~HALSimWSProviderAddressableLED();
+
+ protected:
+  void RegisterCallbacks() override;
+  void CancelCallbacks() override;
+  void DoCancelCallbacks();
+
+ private:
+  int32_t m_initCbKey = 0;
+  int32_t m_outputPortCbKey = 0;
+  int32_t m_lengthCbKey = 0;
+  int32_t m_runningCbKey = 0;
+  int32_t m_dataCbKey = 0;
+};
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/include/WSProvider_PCM.h b/simulation/halsim_ws_core/src/main/native/include/WSProvider_PCM.h
new file mode 100644
index 0000000000..92585ad42c
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/include/WSProvider_PCM.h
@@ -0,0 +1,31 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <string>
+
+#include "WSHalProviders.h"
+
+namespace wpilibws {
+class HALSimWSProviderPCM : public HALSimWSHalChanProvider {
+ public:
+  static void Initialize(WSRegisterFunc webRegisterFunc);
+
+  using HALSimWSHalChanProvider::HALSimWSHalChanProvider;
+  ~HALSimWSProviderPCM();
+
+ protected:
+  void RegisterCallbacks() override;
+  void CancelCallbacks() override;
+  void DoCancelCallbacks();
+
+ private:
+  int32_t m_initCbKey = 0;
+  int32_t m_onCbKey = 0;
+  int32_t m_closedLoopCbKey = 0;
+  int32_t m_pressureSwitchCbKey = 0;
+  int32_t m_currentCbKey = 0;
+};
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/include/WSProvider_PDP.h b/simulation/halsim_ws_core/src/main/native/include/WSProvider_PDP.h
new file mode 100644
index 0000000000..270e6a00b4
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/include/WSProvider_PDP.h
@@ -0,0 +1,51 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <string>
+
+#include "WSHalProviders.h"
+
+namespace wpilibws {
+class HALSimWSProviderPDP : public HALSimWSHalChanProvider {
+ public:
+  static void Initialize(WSRegisterFunc webRegisterFunc);
+
+  using HALSimWSHalChanProvider::HALSimWSHalChanProvider;
+  ~HALSimWSProviderPDP();
+
+ protected:
+  void RegisterCallbacks() override;
+  void CancelCallbacks() override;
+  void DoCancelCallbacks();
+
+ private:
+  int32_t m_initCbKey = 0;
+  int32_t m_temperatureCbKey = 0;
+  int32_t m_voltageCbKey = 0;
+};
+
+class HALSimWSProviderPDPChannelCurrent : public HALSimWSHalProvider {
+ public:
+  static void Initialize(WSRegisterFunc webRegisterFunc);
+
+  explicit HALSimWSProviderPDPChannelCurrent(int32_t pdpChannel,
+                                             int32_t currentChannel,
+                                             const std::string& key,
+                                             const std::string& type);
+  ~HALSimWSProviderPDPChannelCurrent();
+
+ protected:
+  void RegisterCallbacks() override;
+  void CancelCallbacks() override;
+  void DoCancelCallbacks();
+
+ private:
+  int32_t m_pdpIndex = 0;
+  int32_t m_channelIndex = 0;
+
+  int32_t m_currentCbKey = 0;
+};
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_core/src/main/native/include/WSProvider_Solenoid.h b/simulation/halsim_ws_core/src/main/native/include/WSProvider_Solenoid.h
new file mode 100644
index 0000000000..e288345953
--- /dev/null
+++ b/simulation/halsim_ws_core/src/main/native/include/WSProvider_Solenoid.h
@@ -0,0 +1,33 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <string>
+
+#include "WSHalProviders.h"
+
+namespace wpilibws {
+class HALSimWSProviderSolenoid : public HALSimWSHalProvider {
+ public:
+  static void Initialize(WSRegisterFunc webRegisterFunc);
+
+  explicit HALSimWSProviderSolenoid(int32_t pcmChannel, int32_t solenoidChannel,
+                                    const std::string& key,
+                                    const std::string& type);
+  ~HALSimWSProviderSolenoid();
+
+ protected:
+  void RegisterCallbacks() override;
+  void CancelCallbacks() override;
+  void DoCancelCallbacks();
+
+ private:
+  int32_t m_pcmIndex = 0;
+  int32_t m_solenoidIndex = 0;
+
+  int32_t m_initCbKey = 0;
+  int32_t m_outputCbKey = 0;
+};
+}  // namespace wpilibws
diff --git a/simulation/halsim_ws_server/src/main/native/cpp/HALSimWSServer.cpp b/simulation/halsim_ws_server/src/main/native/cpp/HALSimWSServer.cpp
index decbebb261..9ecccb049c 100644
--- a/simulation/halsim_ws_server/src/main/native/cpp/HALSimWSServer.cpp
+++ b/simulation/halsim_ws_server/src/main/native/cpp/HALSimWSServer.cpp
@@ -5,16 +5,19 @@
 #include "HALSimWSServer.h"
 
 #include <WSProviderContainer.h>
+#include <WSProvider_AddressableLED.h>
 #include <WSProvider_Analog.h>
 #include <WSProvider_BuiltInAccelerometer.h>
 #include <WSProvider_DIO.h>
 #include <WSProvider_DriverStation.h>
 #include <WSProvider_Encoder.h>
 #include <WSProvider_Joystick.h>
+#include <WSProvider_PCM.h>
 #include <WSProvider_PWM.h>
 #include <WSProvider_Relay.h>
 #include <WSProvider_RoboRIO.h>
 #include <WSProvider_SimDevice.h>
+#include <WSProvider_Solenoid.h>
 #include <WSProvider_dPWM.h>
 
 using namespace wpilibws;
@@ -33,6 +36,7 @@ bool HALSimWSServer::Initialize() {
       providers.Add(key, provider);
     };
 
+    HALSimWSProviderAddressableLED::Initialize(registerFunc);
     HALSimWSProviderAnalogIn::Initialize(registerFunc);
     HALSimWSProviderAnalogOut::Initialize(registerFunc);
     HALSimWSProviderBuiltInAccelerometer::Initialize(registerFunc);
@@ -41,9 +45,11 @@ bool HALSimWSServer::Initialize() {
     HALSimWSProviderDriverStation::Initialize(registerFunc);
     HALSimWSProviderEncoder::Initialize(registerFunc);
     HALSimWSProviderJoystick::Initialize(registerFunc);
+    HALSimWSProviderPCM::Initialize(registerFunc);
     HALSimWSProviderPWM::Initialize(registerFunc);
     HALSimWSProviderRelay::Initialize(registerFunc);
     HALSimWSProviderRoboRIO::Initialize(registerFunc);
+    HALSimWSProviderSolenoid::Initialize(registerFunc);
 
     simDevices.Initialize(loop);