diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/AboutProjectWideActions.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/AboutProjectWideActions.cs
new file mode 100644
index 0000000000..99ee49ef9c
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/AboutProjectWideActions.cs
@@ -0,0 +1,12 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class AboutProjectWideActions : MonoBehaviour
+{
+    void Start()
+    {
+        #region about-project-wide-actions
+        InputSystem.actions.FindAction("Move");
+        #endregion
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/BindingConflicts.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/BindingConflicts.cs
new file mode 100644
index 0000000000..4417fac872
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/BindingConflicts.cs
@@ -0,0 +1,40 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+class BindingConflictsExample : InputTestFixture
+{
+    public void Example()
+    {
+        #region bindingConflicts
+        // Create two actions in the same map.
+        var map = new InputActionMap();
+        var bAction = map.AddAction("B");
+        var shiftbAction = map.AddAction("ShiftB");
+
+        // Bind one of the actions to 'B' and the other to 'SHIFT+B'.
+        bAction.AddBinding("<Keyboard>/b");
+        shiftbAction.AddCompositeBinding("OneModifier")
+            .With("Modifier", "<Keyboard>/shift")
+            .With("Binding", "<Keyboard>/b");
+
+        // Print something to the console when the actions are triggered.
+        bAction.performed += _ => Debug.Log("B action performed");
+        shiftbAction.performed += _ => Debug.Log("SHIFT+B action performed");
+
+        // Start listening to input.
+        map.Enable();
+
+        // Now, let's assume the left shift key on the keyboard is pressed (here, we manually
+        // press it with the InputTestFixture API).
+        Press(Keyboard.current.leftShiftKey);
+
+        // And then the B is pressed. This is a valid input for both
+        // bAction as well as shiftbAction.
+        //
+        // What will happen now is that shiftbAction will do its processing first. In response,
+        // it will *perform* the action (That is, we see the `performed` callback being invoked) and
+        // thus "consume" the input. bAction will stay silent as it will in turn be skipped over.
+        Press(Keyboard.bKey);
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs
new file mode 100644
index 0000000000..fc01f66925
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs
@@ -0,0 +1,69 @@
+namespace DocCodeSamples.Tests
+{
+    #region declaration
+    using UnityEngine;
+    using UnityEngine.InputSystem;
+
+    public class ExampleScript : MonoBehaviour
+    {
+        public InputAction move;
+        public InputAction jump;
+    }
+    #endregion
+
+    class ConfigureInputfromCode : MonoBehaviour
+    {
+        const string json = @"
+        {
+            ""maps"" : [
+                {
+                    ""name"" : ""gameplay"",
+                    ""actions"" : [
+                        { ""name"" : ""fire"", ""type"" : ""button"" }
+                    ]
+                }
+            ]
+        }";
+
+        void ConfigureFromJsonExample()
+        {
+            #region configurefromjson
+            // Load a set of action maps from JSON.
+            var maps = InputActionMap.FromJson(json);
+
+            // Load an entire InputActionAsset from JSON.
+            var asset = InputActionAsset.FromJson(json);
+            #endregion
+        }
+
+        void Start()
+        {
+            #region configurefromcode
+            {
+                // Create free-standing actions.
+                var lookAction = new InputAction("look", binding: "<Gamepad>/leftStick");
+                var moveAction = new InputAction("move", binding: "<Gamepad>/rightStick");
+
+                moveAction.AddCompositeBinding("1DAxis")
+                    .With("Left", "<Keyboard>/a")
+                    .With("Right", "<Keyboard>/d");
+            }
+
+            {
+                // Create an action map with actions.
+                var map = new InputActionMap("Gameplay");
+                var lookAction = map.AddAction("look");
+                lookAction.AddBinding("<Gamepad>/leftStick");
+            }
+
+            {
+                // Create an action asset.
+                var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+                var gameplayMap = new InputActionMap("gameplay");
+                asset.AddActionMap(gameplayMap);
+                var lookAction = gameplayMap.AddAction("look", "<Gamepad>/leftStick");
+            }
+            #endregion
+        }
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlActuation.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlActuation.cs
new file mode 100644
index 0000000000..eea34f9510
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlActuation.cs
@@ -0,0 +1,22 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+class ControlActuation : MonoBehaviour
+{
+    void Example(){
+
+    #region actuation
+    // Check if leftStick is currently actuated.
+    if (Gamepad.current.leftStick.IsActuated())
+        Debug.Log("Left Stick is actuated");
+    #endregion
+
+    #region actuation2
+    // Check if left stick is actuated more than a quarter of its motion range.
+    if (Gamepad.current.leftStick.EvaluateMagnitude() > 0.25f)
+        Debug.Log("Left Stick actuated past 25%");
+    #endregion
+
+    }
+
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlPaths.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlPaths.cs
new file mode 100644
index 0000000000..4e84a57ff7
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlPaths.cs
@@ -0,0 +1,27 @@
+using System.Linq;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+class ControlPathsExample
+{
+    void Example()
+    {
+        #region parse
+        var parsed = InputControlPath.Parse("<XRController>{LeftHand}/trigger").ToArray();
+
+        Debug.Log(parsed.Length); // Prints 2.
+        Debug.Log(parsed[0].layout); // Prints "XRController".
+        Debug.Log(parsed[0].name); // Prints an empty string.
+        Debug.Log(parsed[0].usages.First()); // Prints "LeftHand".
+        Debug.Log(parsed[1].layout); // Prints null.
+        Debug.Log(parsed[1].name); // Prints "trigger".
+        #endregion
+
+        #region findcontrols
+        var gamepad = Gamepad.all[0];
+        var leftStickX = gamepad["leftStick/x"];
+        var submitButton = gamepad["{Submit}"];
+        var allSubmitButtons = InputSystem.FindControls("*/{Submit}");
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs
new file mode 100644
index 0000000000..47d0e4cd36
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs
@@ -0,0 +1,56 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Editor;
+
+namespace DocCodeSamples.Tests
+{
+    #region registernewprocessor
+    #if UNITY_EDITOR
+    [InitializeOnLoad]
+    #endif
+    public class MyValueShiftProcessor : InputProcessor<float>
+    {
+        #if UNITY_EDITOR
+        static MyValueShiftProcessor()
+        {
+            Initialize();
+        }
+        #endif
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void Initialize()
+        {
+            InputSystem.RegisterProcessor<MyValueShiftProcessor>();
+        }
+
+        //...
+    }
+    #endregion
+
+    class ProcessorExamples: MonoBehaviour
+    {
+        void Start()
+        {
+            #region inputactionwithprocessor
+            var action = new InputAction(processors: "myvalueshift(valueShift=2.3)");
+            #endregion
+        }
+
+        void ConfigureProcessorBinding()
+        {
+            #region processorbindings
+            var action = new InputAction();
+            action.AddBinding("<Gamepad>/leftStick")
+            .WithProcessor("invertVector2(invertX=false)");
+            #endregion
+        }
+
+        void AddProcessor()
+        {
+            #region addprocessor
+            var action = new InputAction(processors: "invertVector2(invertX=false)");
+            #endregion
+        }
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DefaultActions.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DefaultActions.cs
new file mode 100644
index 0000000000..3097df15c1
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DefaultActions.cs
@@ -0,0 +1,26 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class DefaultActions : MonoBehaviour
+{
+    #region default-actions
+    void Start()
+    {
+        // Create an instance of the default actions.
+        var actions = new DefaultInputActions();
+        actions.Player.Look.performed += OnLook;
+        actions.Player.Move.performed += OnMove;
+        actions.Enable();
+    }
+    #endregion
+
+    void OnLook(InputAction.CallbackContext context)
+    {
+        // your look code here
+    }
+
+    void OnMove(InputAction.CallbackContext context)
+    {
+        // your move code here
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GenerateCsApiFromActions.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GenerateCsApiFromActions.cs
new file mode 100644
index 0000000000..941bb4d143
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GenerateCsApiFromActions.cs
@@ -0,0 +1,43 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+// IGameplayActions is an interface generated from the newly added "gameplay"
+// action map, triggered by the "Generate Interfaces" checkbox. Note that if
+// you change the default values for the action map, the name of the interface
+// will be different.
+
+public class MyPlayerScript : MonoBehaviour, IGameplayActions
+{
+    // MyPlayerControls is the C# class that Unity generated.
+    // It encapsulates the data from the .inputactions asset we created
+    // and automatically looks up all the maps and actions for us.
+    MyPlayerControls controls;
+
+    public void OnEnable()
+    {
+        if (controls == null)
+        {
+            controls = new MyPlayerControls();
+            // Tell the "gameplay" action map that we want to be
+            // notified when actions get triggered.
+            controls.gameplay.SetCallbacks(this);
+        }
+        controls.gameplay.Enable();
+    }
+
+    public void OnDisable()
+    {
+        controls.gameplay.Disable();
+    }
+
+    public void OnUse(InputAction.CallbackContext context)
+    {
+        // 'Use' code here.
+    }
+
+    public void OnMove(InputAction.CallbackContext context)
+    {
+        // 'Move' code here.
+    }
+
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs
new file mode 100644
index 0000000000..da84192fd3
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs
@@ -0,0 +1,125 @@
+namespace DocCodeSamples.Tests
+{
+    #region interactions
+    using UnityEngine;
+    using UnityEngine.InputSystem;
+    using UnityEngine.InputSystem.Interactions;
+
+    public class ExampleScript : MonoBehaviour
+    {
+        InputAction jumpAction;
+
+        private void Start()
+        {
+            jumpAction = InputSystem.actions.FindAction("Jump");
+
+
+            jumpAction.started += context =>
+            {
+                if (context.interaction is SlowTapInteraction)
+                {
+                    // Show "charging" UI
+                }
+            };
+
+            jumpAction.performed += context =>
+            {
+                if (context.interaction is SlowTapInteraction)
+                {
+                    // call "charged jump" code
+                }
+                else
+                {
+                    // call "regular jump" code
+                };
+            };
+
+            jumpAction.canceled += context =>
+            {
+                // Hide "charging" UI
+            };
+
+        }
+    }
+    #endregion
+
+    class ExampleScript2 : MonoBehaviour
+    {
+        public PlayerInput playerInput;
+
+        private void Start()
+        {
+            #region timeout
+            // Returns a value between 0 (inclusive) and 1 (inclusive).
+            var warpActionCompletion = playerInput.actions["warp"].GetTimeoutCompletionPercentage();
+            #endregion
+
+            #region interactionactions
+            var Action = new InputAction(interactions: "tap(duration=0.8)");
+            #endregion
+        }
+
+        private void ConfigureBindingInteractions()
+        {
+            #region interactionbindings
+            var Action = new InputAction();
+            Action.AddBinding("<Gamepad>/leftStick").WithInteractions("tap(duration=0.8)");
+            #endregion
+        }
+    }
+
+    #region custominteraction
+    // Interaction which performs when you quickly move an
+    // axis all the way from extreme to the other.
+    public class MyExampleInteraction : IInputInteraction
+    {
+        public float duration = 0.2f;
+
+        public void Process(ref InputInteractionContext context)
+        {
+            if (context.timerHasExpired)
+            {
+                context.Canceled();
+                return;
+            }
+
+            switch (context.phase)
+            {
+                case InputActionPhase.Waiting:
+                    if (context.ReadValue<float>() == 1)
+                    {
+                        context.Started();
+                        context.SetTimeout(duration);
+                    }
+                    break;
+
+                case InputActionPhase.Started:
+                    if (context.ReadValue<float>() == -1)
+                        context.Performed();
+                    break;
+            }
+        }
+
+        // Unlike processors, Interactions can be stateful, meaning that you can keep a
+        // local state that changes over time as input is received. The system might
+        // invoke the Reset() method to ask Interactions to reset to the local state
+        // at certain points.
+        public void Reset()
+        {
+        }
+
+        void Start()
+        {
+            #region registerinteraction
+            InputSystem.RegisterInteraction<MyExampleInteraction>();
+            #endregion
+
+            #region useinteraction
+            var Action = new InputAction(interactions: "MyExample(duration=0.5)");
+            #endregion
+        }
+    }
+    #endregion
+}
+
+
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorControls.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorControls.cs
new file mode 100644
index 0000000000..2d2c4e3746
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorControls.cs
@@ -0,0 +1,37 @@
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.LowLevel;
+using UnityEngine.InputSystem.Utilities;
+
+#region mydevice
+public struct MyDeviceState : IInputStateTypeInfo
+{
+    public FourCC format => new FourCC('M', 'Y', 'D', 'V');
+
+    // Add an axis deadzone to the Control to ignore values
+    // smaller then 0.2, as our Control does not have a stable
+    // resting position.
+    [InputControl(layout = "Axis", processors = "AxisDeadzone(min=0.2)")]
+    public short axis;
+}
+#endregion
+
+class MyDeviceLayoutJson
+{
+    const string json = @"
+    #region mydevicejson
+    {
+        ""name"" : ""MyDevice"",
+        ""extend"" : ""Gamepad"", // Or some other thing
+        ""controls"" : [
+            {
+                ""name"" : ""axis"",
+                ""layout"" : ""Axis"",
+                ""offset"" : 4,
+                ""format"" : ""FLT"",
+                ""processors"" : ""AxisDeadzone(min=0.2)""
+            }
+        ]
+    }
+    #endregion
+";
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs
new file mode 100644
index 0000000000..998c414f1a
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs
@@ -0,0 +1,76 @@
+using UnityEditor;
+using UnityEngine.InputSystem.Editor;
+#region boat
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class Boat : MonoBehaviour
+{
+    void OnMove(InputValue value)
+    {
+        // The X value will be used to rotate the boat
+        var stick = value.Get<Vector2>();
+        var direction = stick.x;
+        transform.Rotate(Vector3.up, direction);
+        // To move the boat forwards, this code block uses the Y value of the stick
+        var speed = stick.y;
+        transform.Translate(new Vector3(0,0,speed),Space.Self);
+    }
+}
+#endregion
+
+class ProcessorsExamples : MonoBehaviour
+{
+    void Start()
+    {
+        #region processors
+        // This references the processor registered as "scale" and sets its "factor"
+        // parameter (a floating-point value) to a value of 2.5.
+        "scale(factor=2.5)";
+
+        // Multiple processors can be chained together. They are processed
+        // from left to right.
+        // Example: First invert the value, then normalize [0..10] values to [0..1].
+        "invert,normalize(min=0,max=10)";
+        #endregion
+    }
+}
+
+#region myvalueprocessor
+public class MyValueShiftProcessor : InputProcessor<float>
+{
+    [Tooltip("Number to add to incoming values.")]
+    public float valueShift = 0;
+
+    public override float Process(float value, InputControl control)
+    {
+        return value + valueShift;
+    }
+}
+#endregion
+
+#region customizeUI
+// No registration is necessary for an InputParameterEditor.
+// The system automatically finds subclasses based on the
+// <..> type parameter.
+#if UNITY_EDITOR
+public class MyValueShiftProcessorEditor : InputParameterEditor<MyValueShiftProcessor>
+{
+    private GUIContent m_SliderLabel = new GUIContent("Shift By");
+
+    public override void OnEnable()
+    {
+        // Put initialization code here. Use 'target' to refer
+        // to the instance of MyValueShiftProcessor that is being
+        // edited.
+    }
+
+    public override void OnGUI()
+    {
+        // Define your custom UI here using EditorGUILayout.
+        target.valueShift = EditorGUILayout.Slider(m_SliderLabel,
+            target.valueShift, 0, 10);
+    }
+}
+#endif
+#endregion
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/QuickStartGuide.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/QuickStartGuide.cs
new file mode 100644
index 0000000000..f476ccd5b2
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/QuickStartGuide.cs
@@ -0,0 +1,35 @@
+namespace DocCodeSamples.Tests
+{
+#region quick-start-guide
+using UnityEngine;
+using UnityEngine.InputSystem;  // 1. The Input System "using" statement
+
+public class Example : MonoBehaviour
+{
+    // 2. These variables are to hold the Action references
+    InputAction moveAction;
+    InputAction jumpAction;
+
+    private void Start()
+    {
+        // 3. Find the references to the "Move" and "Jump" actions
+        moveAction = InputSystem.actions.FindAction("Move");
+        jumpAction = InputSystem.actions.FindAction("Jump");
+    }
+
+    void Update()
+    {
+        // 4. Read the "Move" action value, which is a 2D vector
+        // and the "Jump" action state, which is a boolean value
+
+        Vector2 moveValue = moveAction.ReadValue<Vector2>();
+        // your movement code here
+
+        if (jumpAction.IsPressed())
+        {
+            // your jump code here
+        }
+    }
+}
+#endregion
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/RecordControlStateHistory.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/RecordControlStateHistory.cs
new file mode 100644
index 0000000000..e7e9ef7992
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/RecordControlStateHistory.cs
@@ -0,0 +1,59 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+class RecordControlStateHistoryExample 
+{
+    void Example()
+    {
+    #region history
+    // Create history that records Vector2 control value changes.
+    // NOTE: You can also pass controls directly or use paths that match multiple
+    //       controls (For example, "<Gamepad>/<Button>").
+    // NOTE: The unconstrained InputStateHistory class can record changes on controls
+    //        of different value types.
+    var history = new InputStateHistory<Vector2>("<Touchscreen>/primaryTouch/position");
+
+    // To start recording state changes of the controls to which the history
+    // is attached, call StartRecording.
+    history.StartRecording();
+
+    // To stop recording state changes, call StopRecording.
+    history.StopRecording();
+
+    // Recorded history can be accessed like an array.
+    for (var i = 0; i < history.Count; ++i)
+    {
+        // Each recorded value provides information about which control changed
+        // value (in cases state from multiple controls is recorded concurrently
+        // by the same InputStateHistory) and when it did so.
+
+        var time = history[i].time;
+        var control = history[i].control;
+        var value = history[i].ReadValue();
+    }
+
+    // Recorded history can also be iterated over.
+    foreach (var record in history)
+        Debug.Log(record.ReadValue());
+    Debug.Log(string.Join(",\n", history));
+
+    // You can also record state changes manually, which allows
+    // storing arbitrary histories in InputStateHistory.
+    // NOTE: This records a value change that didn't actually happen on the control.
+    history.RecordStateChange(Touchscreen.current.primaryTouch.position,
+        new Vector2(0.123f, 0.234f));
+
+    // State histories allocate unmanaged memory and need to be disposed.
+    history.Dispose();
+    #endregion
+    }
+
+    void Example100Samples()
+    {
+        #region 100samples
+        var history = new InputStateHistory<Vector2>(Gamepad.current.leftStick);
+        history.historyDepth = 100;
+        history.StartRecording();
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs
new file mode 100644
index 0000000000..8780d6ca33
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs
@@ -0,0 +1,29 @@
+using UnityEngine;
+#region using
+using UnityEngine.InputSystem;
+#endregion
+
+namespace DocCodeSamples.Tests
+{
+    internal class UsingActionsWorkflowExamples : MonoBehaviour
+    {
+        #region InputAction_variables
+        InputAction moveAction;
+        InputAction jumpAction;
+        #endregion
+
+        private void Start() {
+        #region FindAction
+        moveAction = InputSystem.actions.FindAction("Move");
+        jumpAction = InputSystem.actions.FindAction("Jump");
+        #endregion
+        }
+
+        private void Update() {
+        #region ReadActionValues
+        Vector2 moveValue = moveAction.ReadValue<Vector2>();
+        bool jumpValue = jumpAction.IsPressed();
+        #endregion
+        }
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowFullExample.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowFullExample.cs
new file mode 100644
index 0000000000..991588e494
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowFullExample.cs
@@ -0,0 +1,30 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class Example : MonoBehaviour
+{
+    // These variables are to hold the Action references
+    InputAction moveAction;
+    InputAction jumpAction;
+
+    private void Start()
+    {
+        // Find the references to the "Move" and "Jump" actions
+        moveAction = InputSystem.actions.FindAction("Move");
+        jumpAction = InputSystem.actions.FindAction("Jump");
+    }
+
+    void Update()
+    {
+        // Read the "Move" action value, which is a 2D vector
+        // and the "Jump" action state, which is a boolean value
+
+        Vector2 moveValue = moveAction.ReadValue<Vector2>();
+        // your movement code here
+
+        if (jumpAction.IsPressed())
+        {
+            // your jump code here
+        }
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingDirectWorkflow.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingDirectWorkflow.cs
new file mode 100644
index 0000000000..016a40374b
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingDirectWorkflow.cs
@@ -0,0 +1,24 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class MyPlayerScript : MonoBehaviour
+{
+    void Update()
+    {
+        var gamepad = Gamepad.current;
+        if (gamepad == null)
+        {
+            return; // No gamepad connected.
+        }
+
+        if (gamepad.rightTrigger.wasPressedThisFrame)
+        {
+            // 'Use' code here
+        }
+
+        Vector2 move = gamepad.leftStick.ReadValue();
+        {
+            // 'Move' code here
+        }
+    }
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingPlayerinputWorkflow.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingPlayerinputWorkflow.cs
new file mode 100644
index 0000000000..81b6a48b50
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingPlayerinputWorkflow.cs
@@ -0,0 +1,28 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+// This script is designed to have the OnMove and
+// OnJump methods called by a PlayerInput component
+
+public class ExampleScript : MonoBehaviour
+{
+    Vector2 moveAmount;
+
+    public void OnMove(InputAction.CallbackContext context)
+    {
+        // read the value for the "move" action each event call
+        moveAmount = context.ReadValue<Vector2>();
+    }
+
+    public void OnJump(InputAction.CallbackContext context)
+    {
+        // your jump code goes here.
+    }
+
+    public void Update()
+    {
+        // to use the Vector2 value from the "move" action each
+        // frame, use the "moveAmount" variable here.
+    }
+
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/Documentation~/about-project-wide-actions.md b/Packages/com.unity.inputsystem/Documentation~/about-project-wide-actions.md
index df727a5287..2c101b6e94 100644
--- a/Packages/com.unity.inputsystem/Documentation~/about-project-wide-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/about-project-wide-actions.md
@@ -24,8 +24,6 @@ The benefit of assign an action asset as the project-wide actions is that you ca
 
 For example, you can get a reference to an action named "Move" in your project-wide actions using a line of code like this:
 
-```
-  InputSystem.actions.FindAction("Move");
-```
+  [!code-cs[project-wide actions](Packages/com.unity.inputsystem/DocCodeSamples.Tests/AboutProjectWideActions.cs#about-project-wide-actions)]
 
 Project-wide actions are also enabled by default.
diff --git a/Packages/com.unity.inputsystem/Documentation~/add-processors-bindings-actions.md b/Packages/com.unity.inputsystem/Documentation~/add-processors-bindings-actions.md
index df67b202f6..5f9e5c8d7e 100644
--- a/Packages/com.unity.inputsystem/Documentation~/add-processors-bindings-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/add-processors-bindings-actions.md
@@ -23,11 +23,7 @@ To remove a Processor, click the Remove (-) icon next to it. You can also use th
 
 If you create your bindings in code, you can add Processors like this:
 
-```CSharp
-var action = new InputAction();
-action.AddBinding("<Gamepad>/leftStick")
-    .WithProcessor("invertVector2(invertX=false)");
-```
+[!code-cs[processorbindings](Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs#processorbindings)]
 
 ## Processors on Actions
 
@@ -37,6 +33,4 @@ You can add and edit Processors on Actions in the [Input Actions Editor](actions
 
 If you create your Actions in code, you can add Processors like this:
 
-```CSharp
-var action = new InputAction(processors: "invertVector2(invertX=false)");
-```
+[!code-cs[addprocessor](Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs#addprocessor)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/add-processors-controls.md b/Packages/com.unity.inputsystem/Documentation~/add-processors-controls.md
index a73eb63176..6d332c926c 100644
--- a/Packages/com.unity.inputsystem/Documentation~/add-processors-controls.md
+++ b/Packages/com.unity.inputsystem/Documentation~/add-processors-controls.md
@@ -10,33 +10,8 @@ The Input System adds Processors to a Control during device creation, if they're
 
 If you're using a layout generated by the Input System from a [state struct](step-1-state-struct.md) using [`InputControlAttributes`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute), you can specify the Processors you want to use with the [`processors`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute) property of the attribute, like this:
 
-```CSharp
-public struct MyDeviceState : IInputStateTypeInfo
-{
-    public FourCC format => return new FourCC('M', 'Y', 'D', 'V');
-
-    // Add an axis deadzone to the Control to ignore values
-    // smaller then 0.2, as our Control does not have a stable
-    // resting position.
-    [InputControl(layout = "Axis", processors = "AxisDeadzone(min=0.2)")]
-    public short axis;
-}
-```
+[!code-cs[mydevice](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorControls.cs#mydevice)]
 
 If you [create a layout from JSON](add-layout-from-json.md), you can specify Processors on your Controls like this:
 
-```CSharp
-{
-    "name" : "MyDevice",
-    "extend" : "Gamepad", // Or some other thing
-    "controls" : [
-        {
-            "name" : "axis",
-            "layout" : "Axis",
-            "offset" : 4,
-            "format" : "FLT",
-            "processors" : "AxisDeadzone(min=0.2)"
-        }
-    ]
-}
-```
+[!code-cs[mydevicejson](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorControls.cs#mydevicejson)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/apply-interactions-actions.md b/Packages/com.unity.inputsystem/Documentation~/apply-interactions-actions.md
index 7810dea955..f89d6f24a0 100644
--- a/Packages/com.unity.inputsystem/Documentation~/apply-interactions-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/apply-interactions-actions.md
@@ -23,6 +23,4 @@ To apply interactions in the Input Action Editor:
 
 If you create your Actions in code, you can add Interactions like this:
 
-```CSharp
-var Action = new InputAction(Interactions: "tap(duration=0.8)");
-```
+[!code-cs[interactionactions](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#interactionactions)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/apply-interactions-bindings.md b/Packages/com.unity.inputsystem/Documentation~/apply-interactions-bindings.md
index 2ffa2d337f..180a06db5d 100644
--- a/Packages/com.unity.inputsystem/Documentation~/apply-interactions-bindings.md
+++ b/Packages/com.unity.inputsystem/Documentation~/apply-interactions-bindings.md
@@ -25,8 +25,4 @@ To remove an Interaction, select the minus (-) button next to it. To change the
 
 To add Interactions to bindings that you created in code, you can use the following code sample as a template:
 
-```CSharp
-var Action = new InputAction();
-action.AddBinding("<Gamepad>/leftStick")
-    .WithInteractions("tap(duration=0.8)");
-```
+[!code-cs[interactionbindings](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#interactionbindings)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md b/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md
index bc9e96ddd8..1860a26ead 100644
--- a/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md
+++ b/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md
@@ -62,34 +62,4 @@ By using the **Pass Through** action type, conflict resolution is bypassed, whic
 
 The following example illustrates how this works at the API level.
 
-```CSharp
-// Create two actions in the same map.
-var map = new InputActionMap();
-var bAction = map.AddAction("B");
-var shiftbAction = map.AddAction("ShiftB");
-
-// Bind one of the actions to 'B' and the other to 'SHIFT+B'.
-bAction.AddBinding("<Keyboard>/b");
-shiftbAction.AddCompositeBinding("OneModifier")
-    .With("Modifier", "<Keyboard>/shift")
-    .With("Binding", "<Keyboard>/b");
-
-// Print something to the console when the actions are triggered.
-bAction.performed += _ => Debug.Log("B action performed");
-shiftbAction.performed += _ => Debug.Log("SHIFT+B action performed");
-
-// Start listening to input.
-map.Enable();
-
-// Now, let's assume the left shift key on the keyboard is pressed (here, we manually
-// press it with the InputTestFixture API).
-Press(Keyboard.current.leftShiftKey);
-
-// And then the B is pressed. This is a valid input for both
-// bAction as well as shiftbAction.
-//
-// What will happen now is that shiftbAction will do its processing first. In response,
-// it will *perform* the action (That is, we see the `performed` callback being invoked) and
-// thus "consume" the input. bAction will stay silent as it will in turn be skipped over.
-Press(keyboard.bKey);
-```
+[!code-cs[bindingconflicts](Packages/com.unity.inputsystem/DocCodeSamples.Tests/BindingConflicts.cs#bindingConflicts)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/configure-input-from-json.md b/Packages/com.unity.inputsystem/Documentation~/configure-input-from-json.md
index c1d784d2c4..1f24ba7f39 100644
--- a/Packages/com.unity.inputsystem/Documentation~/configure-input-from-json.md
+++ b/Packages/com.unity.inputsystem/Documentation~/configure-input-from-json.md
@@ -6,10 +6,4 @@ uid: input-system-configure-input-from-json
 
 You can load actions as JSON in the form of a set of action maps or as a full [`InputActionAsset`](xref:UnityEngine.InputSystem.InputActionAsset). This also works at runtime in the Player.
 
-```CSharp
-// Load a set of action maps from JSON.
-var maps = InputActionMap.FromJson(json);
-
-// Load an entire InputActionAsset from JSON.
-var asset = InputActionAsset.FromJson(json);
-```
+[!code-cs[configurefromjson](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs#configurefromjson)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/control-actuation.md b/Packages/com.unity.inputsystem/Documentation~/control-actuation.md
index 53a08b7e3b..1faf614152 100644
--- a/Packages/com.unity.inputsystem/Documentation~/control-actuation.md
+++ b/Packages/com.unity.inputsystem/Documentation~/control-actuation.md
@@ -16,11 +16,7 @@ However in some scenarios you might want to directly read the actuation of a con
 
 You can query whether a control is currently actuated using [`IsActuated`](xref:UnityEngine.InputSystem.InputControlExtensions).
 
-```CSharp
-// Check if leftStick is currently actuated.
-if (Gamepad.current.leftStick.IsActuated())
-    Debug.Log("Left Stick is actuated");
-```
+[!code-cs[actuation](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlActuation.cs#actuation)]
 
 It can be useful to determine not just whether a control is actuated at all, but also the amount by which it is actuated (that is, its magnitude). For example, for a [`Vector2Control`](xref:UnityEngine.InputSystem.Controls.Vector2Control) this is the length of the vector, whereas for a button it is the raw, absolute floating-point value.
 
@@ -28,11 +24,7 @@ In general, the current magnitude of a control is always greater than or equal t
 
 You can query the current amount of actuation using [`EvaluateMagnitude`](xref:UnityEngine.InputSystem.InputControl).
 
-```CSharp
-// Check if left stick is actuated more than a quarter of its motion range.
-if (Gamepad.current.leftStick.EvaluateMagnitude() > 0.25f)
-    Debug.Log("Left Stick actuated past 25%");
-```
+[!code-cs[actuation2](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlActuation.cs#actuation2)]
 
 These two mechanisms use control actuation:
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/control-paths.md b/Packages/com.unity.inputsystem/Documentation~/control-paths.md
index 4bbc1f7ad2..aeb471854f 100644
--- a/Packages/com.unity.inputsystem/Documentation~/control-paths.md
+++ b/Packages/com.unity.inputsystem/Documentation~/control-paths.md
@@ -82,22 +82,8 @@ If you enter a control path as text, you can use the wildcard asterisk character
 You can access the literal path of a given control with its [`InputControl.path`](xref:UnityEngine.InputSystem.InputControl.path) property. If you need to, you can manually parse a control path into its components using the [`InputControlPath.Parse(path)`](xref:UnityEngine.InputSystem.InputControlPath.Parse(System.String)) API:
 
 
-```CSharp
-var parsed = InputControlPath.Parse("<XRController>{LeftHand}/trigger").ToArray();
-
-Debug.Log(parsed.Length); // Prints 2.
-Debug.Log(parsed[0].layout); // Prints "XRController".
-Debug.Log(parsed[0].name); // Prints an empty string.
-Debug.Log(parsed[0].usages.First()); // Prints "LeftHand".
-Debug.Log(parsed[1].layout); // Prints null.
-Debug.Log(parsed[1].name); // Prints "trigger".
-```
+[!code-cs[parse](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlPaths.cs#parse)]
 
 You can use control paths to directly reference controls, or to let the Input System search for Controls among all devices using [`InputSystem.FindControls`](xref:UnityEngine.InputSystem.InputSystem).
 
-```CSharp
-var gamepad = Gamepad.all[0];
-var leftStickX = gamepad["leftStick/x"];
-var submitButton = gamepad["{Submit}"];
-var allSubmitButtons = InputSystem.FindControls("*/{Submit}");
-```
+[!code-cs[findcontrols](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ControlPaths.cs#findcontrols)]
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/Documentation~/create-actions-in-code.md b/Packages/com.unity.inputsystem/Documentation~/create-actions-in-code.md
index 67f1f1b1d8..a6010d1077 100644
--- a/Packages/com.unity.inputsystem/Documentation~/create-actions-in-code.md
+++ b/Packages/com.unity.inputsystem/Documentation~/create-actions-in-code.md
@@ -6,24 +6,6 @@ uid: input-system-create-actions-in-code
 
 You can manually create and configure actions entirely in code, including assigning the bindings. This also works at runtime in the Player. For example:
 
-```CSharp
-// Create free-standing actions.
-var lookAction = new InputAction("look", binding: "<Gamepad>/leftStick");
-var moveAction = new InputAction("move", binding: "<Gamepad>/rightStick");
-
-    .With("Left", "<Keyboard>/a")
-    .With("Right", "<Keyboard>/d");
-
-// Create an action map with actions.
-var map = new InputActionMap("Gameplay");
-var lookAction = map.AddAction("look");
-lookAction.AddBinding("<Gamepad>/leftStick");
-
-// Create an action asset.
-var asset = ScriptableObject.CreateInstance<InputActionAsset>();
-var gameplayMap = new InputActionMap("gameplay");
-asset.AddActionMap(gameplayMap);
-var lookAction = gameplayMap.AddAction("look", "<Gamepad>/leftStick");
-```
+[!code-cs[configurefromcode](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs#configurefromcode)]
 
 Any action that you create in this way during Play mode doesn't persist in the input action asset after you exit Play mode. This means you can test your application in a realistic manner in the Editor without having to worry about inadvertently modifying the asset.
diff --git a/Packages/com.unity.inputsystem/Documentation~/declare-standalone-actions.md b/Packages/com.unity.inputsystem/Documentation~/declare-standalone-actions.md
index e2c4fd0c9c..02373e37dc 100644
--- a/Packages/com.unity.inputsystem/Documentation~/declare-standalone-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/declare-standalone-actions.md
@@ -6,16 +6,7 @@ uid: input-system-declare-standalone-actions
 
 You can declare individual [`InputAction`](xref:UnityEngine.InputSystem.InputAction) and [`InputActionMap`](xref:UnityEngine.InputSystem.InputActionMap) objects as fields directly inside `MonoBehaviour` components.
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-public class ExampleScript : MonoBehaviour
-{
-    public InputAction move;
-    public InputAction jump;
-}
-```
+[!code-cs[declaration](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ConfigureInputfromCode.cs#declaration)]
 
 The result is similar to using an action defined in the Input Actions Editor, except that you define the actions in the GameObject's properties and save them as scene or prefab data, instead of in a dedicated asset.
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/default-actions.md b/Packages/com.unity.inputsystem/Documentation~/default-actions.md
index c514573edb..12a2430e36 100644
--- a/Packages/com.unity.inputsystem/Documentation~/default-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/default-actions.md
@@ -21,13 +21,4 @@ These default actions mean that in many cases, you can start scripting with the
 The Input System package provides an asset called `DefaultInputActions.inputactions` which you can reference directly in your projects like any other Unity asset. The asset is also available in code form through the [`DefaultInputActions`](xref:UnityEngine.InputSystem.DefaultInputActions) class.
 
 
-```CSharp
-void Start()
-{
-    // Create an instance of the default actions.
-    var actions = new DefaultInputActions();
-    actions.Player.Look.performed += OnLook;
-    actions.Player.Move.performed += OnMove;
-    actions.Enable();
-}
-```
+[!code-cs[default-actions](Packages/com.unity.inputsystem/DocCodeSamples.Tests/DefaultActions.cs#default-actions)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/generate-cs-api-from-actions.md b/Packages/com.unity.inputsystem/Documentation~/generate-cs-api-from-actions.md
index 80aed61fc8..9bd6a3387e 100644
--- a/Packages/com.unity.inputsystem/Documentation~/generate-cs-api-from-actions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/generate-cs-api-from-actions.md
@@ -24,51 +24,7 @@ You can optionally choose a path name, class name, and namespace for the generat
 
 Once applied, the Input System creates a C# script containing API that matches the actions defined in the asset which you can access directly in code. The following example demonstrates this, assuming there is an action map named "gameplay" containing two actions, "use" and "move" defined in the action asset:
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-// IGameplayActions is an interface generated from the newly added "gameplay"
-// action map, triggered by the "Generate Interfaces" checkbox. Note that if
-// you change the default values for the action map, the name of the interface
-// will be different.
-
-public class MyPlayerScript : MonoBehaviour, IGameplayActions
-{
-    // MyPlayerControls is the C# class that Unity generated.
-    // It encapsulates the data from the .inputactions asset we created
-    // and automatically looks up all the maps and actions for us.
-    MyPlayerControls controls;
-
-    public void OnEnable()
-    {
-        if (controls == null)
-        {
-            controls = new MyPlayerControls();
-            // Tell the "gameplay" action map that we want to be
-            // notified when actions get triggered.
-            controls.gameplay.SetCallbacks(this);
-        }
-        controls.gameplay.Enable();
-    }
-
-    public void OnDisable()
-    {
-        controls.gameplay.Disable();
-    }
-
-    public void OnUse(InputAction.CallbackContext context)
-    {
-        // 'Use' code here.
-    }
-
-    public void OnMove(InputAction.CallbackContext context)
-    {
-        // 'Move' code here.
-    }
-
-}
-```
+[!code-cs[generate-cs-api](Packages/com.unity.inputsystem/DocCodeSamples.Tests/GenerateCsApiFromActions.cs)]
 
 > [!NOTE]
 > To regenerate the .cs file, right-click the .inputactions asset in the Project Browser and select **Reimpor**.
diff --git a/Packages/com.unity.inputsystem/Documentation~/introduction-interactions.md b/Packages/com.unity.inputsystem/Documentation~/introduction-interactions.md
index dc390c260c..4b550003b3 100644
--- a/Packages/com.unity.inputsystem/Documentation~/introduction-interactions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/introduction-interactions.md
@@ -32,48 +32,7 @@ While `Performed` is typically the phase that triggers the actual response to an
 
 The following example demonstrates this using a [Slow Tap interaction](./built-in-interactions.md#slowtap) on a `Jump` action so that the user can tap to jump immediately, or hold down the jump button to charge up a higher powered jump, displaying a UI to show the amount charged:
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-using UnityEngine.InputSystem.Interactions;
-
-public class ExampleScript : MonoBehaviour
-{
-    InputAction jumpAction;
-
-    private void Start()
-    {
-        jumpAction = InputSystem.actions.FindAction("Jump");
-
-
-        jumpAction.started += context =>
-        {
-            if (context.interaction is SlowTapInteraction)
-            {
-                // Show "charging" UI
-            }
-        };
-
-        jumpAction.performed += context =>
-        {
-            if (context.interaction is SlowTapInteraction)
-            {
-                // call "charged jump" code
-            }
-            else
-            {
-                // call "regular jump" code
-            };
-        };
-
-        jumpAction.canceled += context =>
-        {
-            // Hide "charging" UI
-        };
-
-    }
-}
-```
+[!code-cs[intro-interactions](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#interactions)]
 
 ## Multiple Controls on an Action
 
@@ -93,10 +52,7 @@ Interactions might need to wait a certain time for a specific input to occur or
 
 It can be useful to know how much of a timeout is left for an interaction to complete. For example, you might want to display a bar in the UI that is charging up while the interaction is waiting to complete. To query the percentage to which a timeout has completed, use [`GetTimeoutCompletionPercentage`](xref:UnityEngine.InputSystem.InputAction).
 
-```CSharp
-// Returns a value between 0 (inclusive) and 1 (inclusive).
-var warpActionCompletion = playerInput.actions["warp"].GetTimeoutCompletionPercentage();
-```
+[!code-cs[timeout](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#timeout)]
 
 Note that each Interaction can have its own separate timeout (but only a single one at any one time). If [multiple interactions](#multiple-interactions-on-a-binding) are in effect, then [`GetTimeoutCompletionPercentage`](xref:UnityEngine.InputSystem.InputAction) will only use the timeout of the one interaction that is currently driving the action.
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/introduction-to-processors.md b/Packages/com.unity.inputsystem/Documentation~/introduction-to-processors.md
index 5a5d38a6b5..327edf3364 100644
--- a/Packages/com.unity.inputsystem/Documentation~/introduction-to-processors.md
+++ b/Packages/com.unity.inputsystem/Documentation~/introduction-to-processors.md
@@ -17,16 +17,7 @@ Each Processor is [registered](xref:UnityEngine.InputSystem.InputSystem) using a
 
 Processors can have parameters which can be booleans, integers, or floating-point numbers. When created in data such as [bindings](./bindings.md), processors are described as strings that look like function calls:
 
-```CSharp
-    // This references the processor registered as "scale" and sets its "factor"
-    // parameter (a floating-point value) to a value of 2.5.
-    "scale(factor=2.5)"
-
-    // Multiple processors can be chained together. They are processed
-    // from left to right.
-    // Example: First invert the value, then normalize [0..10] values to [0..1].
-    "invert,normalize(min=0,max=10)"
-```
+[!code-cs[processors](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs#processors)]
 
 ## Choose the right ProcessorCollapse comment
 
@@ -53,24 +44,7 @@ You can achieve this by using an Invert Processor on the Action or the binding.
 
 Finally, attach the following script to a GameObject with a PlayerInput component that references the corresponding Action Asset:
 
-```csharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-public class Boat : MonoBehaviour
-{
-    void OnMove(InputValue value)
-    {
-        // The X value will be used to rotate the boat
-        var stick = value.Get<Vector2>();
-        var direction = stick.x;
-        transform.Rotate(Vector3.up, direction);
-        // To move the boat forwards, this code block uses the Y value of the stick
-        var speed = stick.y;
-        transform.Translate(new Vector3(0,0,speed),Space.Self);
-    }
-}
-```
+[!code-cs[boat](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs#boat)]
 
 ### Normalize
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/quick-start-guide.md b/Packages/com.unity.inputsystem/Documentation~/quick-start-guide.md
index a507d941b8..57db3ea430 100644
--- a/Packages/com.unity.inputsystem/Documentation~/quick-start-guide.md
+++ b/Packages/com.unity.inputsystem/Documentation~/quick-start-guide.md
@@ -56,38 +56,7 @@ This workflow uses the following steps:
 
 These steps are shown in the example script below:
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;  // 1. The Input System "using" statement
-
-public class Example : MonoBehaviour
-{
-    // 2. These variables are to hold the Action references
-    InputAction moveAction;
-    InputAction jumpAction;
-
-    private void Start()
-    {
-        // 3. Find the references to the "Move" and "Jump" actions
-        moveAction = InputSystem.actions.FindAction("Move");
-        jumpAction = InputSystem.actions.FindAction("Jump");
-    }
-
-    void Update()
-    {
-        // 4. Read the "Move" action value, which is a 2D vector
-        // and the "Jump" action state, which is a boolean value
-
-        Vector2 moveValue = moveAction.ReadValue<Vector2>();
-        // your movement code here
-
-        if (jumpAction.IsPressed())
-        {
-            // your jump code here
-        }
-    }
-}
-```
+[!code-cs[quick-start-guide](Packages/com.unity.inputsystem/DocCodeSamples.Tests/QuickStartGuide.cs#quick-start-guide)]
 
 These actions named "Move" and "Jump" in this script work straight away with no configuration required because they match the names of some of the pre-configured defaults in the Input System package.
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/record-control-state-history.md b/Packages/com.unity.inputsystem/Documentation~/record-control-state-history.md
index b87f796b7e..4277b4063d 100644
--- a/Packages/com.unity.inputsystem/Documentation~/record-control-state-history.md
+++ b/Packages/com.unity.inputsystem/Documentation~/record-control-state-history.md
@@ -6,53 +6,8 @@ uid: input-system-control-state-history
 
 If you want to access the history of value changes on a control (for example, in order to compute exit velocity on a touch release), you can record state changes over time with [`InputStateHistory`](xref:UnityEngine.InputSystem.LowLevel.InputStateHistory) or [`InputStateHistory<TValue>`](xref:UnityEngine.InputSystem.LowLevel.InputStateHistory`1). The latter restricts controls to those of a specific value type, which in turn simplifies some of the API.
 
-
-```CSharp
-// Create history that records Vector2 control value changes.
-// NOTE: You can also pass controls directly or use paths that match multiple
-//       controls (For example, "<Gamepad>/<Button>").
-// NOTE: The unconstrained InputStateHistory class can record changes on controls
-//        of different value types.
-var history = new InputStateHistory<Vector2>("<Touchscreen>/primaryTouch/position");
-
-// To start recording state changes of the controls to which the history
-// is attached, call StartRecording.
-history.StartRecording();
-
-// To stop recording state changes, call StopRecording.
-history.StopRecording();
-
-// Recorded history can be accessed like an array.
-for (var i = 0; i < history.Count; ++i)
-{
-    // Each recorded value provides information about which control changed
-    // value (in cases state from multiple controls is recorded concurrently
-    // by the same InputStateHistory) and when it did so.
-
-    var time = history[i].time;
-    var control = history[i].control;
-    var value = history[i].ReadValue();
-}
-
-// Recorded history can also be iterated over.
-foreach (var record in history)
-    Debug.Log(record.ReadValue());
-Debug.Log(string.Join(",\n", history));
-
-// You can also record state changes manually, which allows
-// storing arbitrary histories in InputStateHistory.
-// NOTE: This records a value change that didn't actually happen on the control.
-history.RecordStateChange(Touchscreen.current.primaryTouch.position,
-    new Vector2(0.123f, 0.234f));
-
-// State histories allocate unmanaged memory and need to be disposed.
-history.Dispose();
-```
+[!code-cs[history](Packages/com.unity.inputsystem/DocCodeSamples.Tests/RecordControlStateHistory.cs#history)]
 
 For example, if you want to have the last 100 samples of the left stick on the gamepad available, you can use this code:
 
-```CSharp
-var history = new InputStateHistory<Vector2>(Gamepad.current.leftStick);
-history.historyDepth = 100;
-history.StartRecording();
-```
+[!code-cs[100samples](Packages/com.unity.inputsystem/DocCodeSamples.Tests/RecordControlStateHistory.cs#100samples)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/using-actions-workflow.md b/Packages/com.unity.inputsystem/Documentation~/using-actions-workflow.md
index ceeec423c5..6b57ea93e7 100644
--- a/Packages/com.unity.inputsystem/Documentation~/using-actions-workflow.md
+++ b/Packages/com.unity.inputsystem/Documentation~/using-actions-workflow.md
@@ -45,57 +45,23 @@ To use `FindAction` to get references to your Actions and read user input in you
 1. Create a new C# script in Unity.
 1. Add the Input System's "using" statement to the top of your script. This allows you to use the Input System API throughout the rest of your script:
 
-        using UnityEngine.InputSystem
+        [!code-cs[using](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs#using)]
 
 1. Create some variables of type `InputAction` in your class body, one for each Action that you want to use in your script. These will store the references to each Action. A good naming convention is to add the word Action to the name of the action. For example:
 
-        InputAction moveAction;
-        InputAction jumpAction;
+        [!code-cs[InputAction_variables](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs#InputAction_variables)]
 
 1. In your Start() method, use `FindAction` to find the reference to each action and store it in its respective variable, for example:
 
-        moveAction = InputSystem.actions.FindAction("Move");
-        jumpAction = InputSystem.actions.FindAction("Jump");
+        [!code-cs[FindAction](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs#FindAction)]
 
 1. In your Update() method, read the value from your action variables. This allows you to write code that reads the latest values coming from your Actions each frame and respond accordingly.<br/><br/>The way you read a value depends on the Action's **value type**. For example some actions might return a 1D or 2D axis value, and other actions might return a Boolean true/false value. In this example, the **Move** action returns a 2D axis, and the **Jump** action returns a Boolean.
 
-        Vector2 moveValue = moveAction.ReadValue<Vector2>();
-        bool jumpValue = jumpAction.IsPressed();
+        [!code-cs[ReadActionValues](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowExamples.cs#ReadActionValues)]
 
 The following example script shows all these steps combined together into a single script:
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-public class Example : MonoBehaviour
-{
-    // These variables are to hold the Action references
-    InputAction moveAction;
-    InputAction jumpAction;
-
-    private void Start()
-    {
-        // Find the references to the "Move" and "Jump" actions
-        moveAction = InputSystem.actions.FindAction("Move");
-        jumpAction = InputSystem.actions.FindAction("Jump");
-    }
-
-    void Update()
-    {
-        // Read the "Move" action value, which is a 2D vector
-        // and the "Jump" action state, which is a boolean value
-
-        Vector2 moveValue = moveAction.ReadValue<Vector2>();
-        // your movement code here
-
-        if (jumpAction.IsPressed())
-        {
-            // your jump code here
-        }
-    }
-}
-```
+[!code-cs[fullexmaple](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingActionsWorkflowFullExample.cs)]
 
 > [!TIP]
 > Aavoid using `FindAction` in your `Update()` loop, because it performs a string-based lookup which could impact performance. This is why the Action references in the example above are found during the Start() function, and stored in variables after finding them.
diff --git a/Packages/com.unity.inputsystem/Documentation~/using-direct-workflow.md b/Packages/com.unity.inputsystem/Documentation~/using-direct-workflow.md
index 171733e41a..dfb8802fc3 100644
--- a/Packages/com.unity.inputsystem/Documentation~/using-direct-workflow.md
+++ b/Packages/com.unity.inputsystem/Documentation~/using-direct-workflow.md
@@ -11,32 +11,7 @@ It can be useful if you want a quick implementation with one specific type of de
 
 You can directly read the values from connected devices by referring to the device’s [controls](controls.md) and reading the values they are currently generating, using code like this:
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-public class MyPlayerScript : MonoBehaviour
-{
-    void Update()
-    {
-        var gamepad = Gamepad.current;
-        if (gamepad == null)
-        {
-            return; // No gamepad connected.
-        }
-
-        if (gamepad.rightTrigger.wasPressedThisFrame)
-        {
-            // 'Use' code here
-        }
-
-        Vector2 move = gamepad.leftStick.ReadValue();
-        {
-            // 'Move' code here
-        }
-    }
-}
-```
+[!code-cs[using-direct-workflow](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingDirectWorkflow.cs)]
 
 The example above reads values directly from  the right trigger, and the left stick, of the currently connected [gamepad](devices-gamepads.md). It does not use the input system’s "Action" class, and instead the conceptual actions in your game or app, such as "move" and "use", are implicitly defined by what your code does in response to the input. You can use the same approach for other Device types such as the [keyboard](xref:UnityEngine.InputSystem.Keyboard) or [mouse](xref:UnityEngine.InputSystem.Mouse).
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/using-playerinput-workflow.md b/Packages/com.unity.inputsystem/Documentation~/using-playerinput-workflow.md
index ddec8aadbc..c2e0eb1220 100644
--- a/Packages/com.unity.inputsystem/Documentation~/using-playerinput-workflow.md
+++ b/Packages/com.unity.inputsystem/Documentation~/using-playerinput-workflow.md
@@ -20,36 +20,7 @@ In the above example image, you can see the PlayerInput component set up to map
 
 This is an example of the script which would provide an implementation of these methods
 
-```CSharp
-using UnityEngine;
-using UnityEngine.InputSystem;
-
-// This script is designed to have the OnMove and
-// OnJump methods called by a PlayerInput component
-
-public class ExampleScript : MonoBehaviour
-{
-    Vector2 moveAmount;
-
-    public void OnMove(InputAction.CallbackContext context)
-    {
-        // read the value for the "move" action each event call
-        moveAmount = context.ReadValue<Vector2>();
-    }
-
-    public void OnJump(InputAction.CallbackContext context)
-    {
-        // your jump code goes here.
-    }
-
-    public void Update()
-    {
-        // to use the Vector2 value from the "move" action each
-        // frame, use the "moveAmount" variable here.
-    }
-
-}
-```
+[!code-cs[player-input-workflow](Packages/com.unity.inputsystem/DocCodeSamples.Tests/UsingPlayerinputWorkflow.cs)]
 
 > [!NOTE]
 > As a general rule, if you are using the PlayerInput workflow, you should read input through callbacks as described above, however if you need to access the input actions asset directly while using the PlayerInput component, you should access the [PlayerInput component's copy of the actions](xref:UnityEngine.InputSystem.PlayerInput), not `InputSystem.actions`.
diff --git a/Packages/com.unity.inputsystem/Documentation~/write-custom-interactions.md b/Packages/com.unity.inputsystem/Documentation~/write-custom-interactions.md
index 4b78874465..e660618584 100644
--- a/Packages/com.unity.inputsystem/Documentation~/write-custom-interactions.md
+++ b/Packages/com.unity.inputsystem/Documentation~/write-custom-interactions.md
@@ -8,58 +8,14 @@ You can also write a custom Interaction to use in your project. You can use cust
 
 Add a class implementing the [`IInputInteraction`](xref:UnityEngine.InputSystem.IInputInteraction) interface, like this:
 
-```CSharp
-// Interaction which performs when you quickly move an
-// axis all the way from extreme to the other.
-public class MyExampleInteraction : IInputInteraction
-{
-    public float duration = 0.2;
-
-    void Process(ref InputInteractionContext context)
-    {
-        if (context.timerHasExpired)
-        {
-            context.Canceled();
-            return;
-        }
-
-        switch (context.phase)
-        {
-            case InputActionPhase.Waiting:
-                if (context.control.ReadValue<float>() == 1)
-                {
-                    context.Started();
-                    context.SetTimeout(duration);
-                }
-                break;
-
-            case InputActionPhase.Started:
-                if (context.control.ReadValue<float>() == -1)
-                    context.Performed();
-                break;
-        }
-    }
-
-    // Unlike processors, Interactions can be stateful, meaning that you can keep a
-    // local state that changes over time as input is received. The system might
-    // invoke the Reset() method to ask Interactions to reset to the local state
-    // at certain points.
-    void Reset()
-    {
-    }
-}
-```
+[!code-cs[custominteraction](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#custominteraction)]
 
 Register your interaction with the Input System in your initialization code:
 
-```CSharp
-InputSystem.RegisterInteraction<MyExampleInteraction>();
-```
+[!code-cs[registerinteraction](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#registerinteraction)]
 
 Your new Interaction is now available in the [Input Action Asset Editor window](xref:input-system-action-assets).
 
 You can also add it in code using this call:
 
-```CSharp
-var Action = new InputAction(Interactions: "MyExample(duration=0.5)");
-```
+[!code-cs[useinteraction](Packages/com.unity.inputsystem/DocCodeSamples.Tests/IntroductionInteractions.cs#useinteraction)]
diff --git a/Packages/com.unity.inputsystem/Documentation~/write-custom-processors.md b/Packages/com.unity.inputsystem/Documentation~/write-custom-processors.md
index 418dcf158d..ecdf2f79c3 100644
--- a/Packages/com.unity.inputsystem/Documentation~/write-custom-processors.md
+++ b/Packages/com.unity.inputsystem/Documentation~/write-custom-processors.md
@@ -16,18 +16,7 @@ To create a custom processor:
 
 **1.** Add a class derived from [`InputProcessor<TValue>`](xref:UnityEngine.InputSystem.InputProcessor`1), and implement the [`Process`](xref:UnityEngine.InputSystem.InputProcessor`1) method:
 
-```CSharp
-public class MyValueShiftProcessor : InputProcessor<float>
-{
-    [Tooltip("Number to add to incoming values.")]
-    public float valueShift = 0;
-
-    public override float Process(float value, InputControl control)
-    {
-        return value + valueShift;
-    }
-}
-```
+[!code-cs[myvalueprocessor](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs#myvalueprocessor)]
 
 > [!IMPORTANT]
 > Processors must be __stateless__, because they are not part of the [input state](control-state.md) that the Input System keeps. For this reason, you can't store local states in a processor if the processor changes based on the input value.
@@ -36,61 +25,14 @@ public class MyValueShiftProcessor : InputProcessor<float>
 
 Register the new processor to the Input System. Call [`InputSystem.RegisterProcessor`](xref:UnityEngine.InputSystem.InputSystem) in your initialization code. You can do this locally within the Processor class:
 
-```CSharp
-#if UNITY_EDITOR
-[InitializeOnLoad]
-#endif
-public class MyValueShiftProcessor : InputProcessor<float>
-{
-    #if UNITY_EDITOR
-    static MyValueShiftProcessor()
-    {
-        Initialize();
-    }
-    #endif
-
-    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
-    static void Initialize()
-    {
-        InputSystem.RegisterProcessor<MyValueShiftProcessor>();
-    }
-
-    //...
-}
-```
+[!code-cs[registernewprocessor](Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs#registernewprocessor)]
 
 Your new Processor is now available in the in the [Input Actions Editor](actions-editor.md) and you can also add it in code like this:
 
-```CSharp
-var action = new InputAction(processors: "myvalueshift(valueShift=2.3)");
-```
+[!code-cs[inputactionwithprocessor](Packages/com.unity.inputsystem/DocCodeSamples.Tests/CustomProcessors.cs#inputactionwithprocessor)]
 
 ## Customize the Editor UI
 
 To customize the UI for editing your Processor, create a custom [`InputParameterEditor`](xref:UnityEngine.InputSystem.Editor.InputParameterEditor`1) class for it:
 
-```CSharp
-// No registration is necessary for an InputParameterEditor.
-// The system automatically finds subclasses based on the
-// <..> type parameter.
-#if UNITY_EDITOR
-public class MyValueShiftProcessorEditor : InputParameterEditor<MyValueShiftProcessor>
-{
-    private GUIContent m_SliderLabel = new GUIContent("Shift By");
-
-    public override void OnEnable()
-    {
-        // Put initialization code here. Use 'target' to refer
-        // to the instance of MyValueShiftProcessor that is being
-        // edited.
-    }
-
-    public override void OnGUI()
-    {
-        // Define your custom UI here using EditorGUILayout.
-        target.valueShift = EditorGUILayout.Slider(m_SliderLabel,
-            target.valueShift, 0, 10);
-    }
-}
-#endif
-```
+[!code-cs[customizeUI](Packages/com.unity.inputsystem/DocCodeSamples.Tests/ProcessorsExamples.cs#customizeUI)]