diff --git a/demonstrations_v2/adjoint_diff_benchmarking/demo.py b/demonstrations_v2/adjoint_diff_benchmarking/demo.py
index 9b0ccff232..5d418d5d88 100644
--- a/demonstrations_v2/adjoint_diff_benchmarking/demo.py
+++ b/demonstrations_v2/adjoint_diff_benchmarking/demo.py
@@ -45,7 +45,7 @@ def circuit(params, wires):
     for i_wires in n_wires:
         dev = qml.device("lightning.qubit", wires=i_wires)
         dev_python = qml.device("default.qubit", wires=i_wires)
-
+"lightning.qubit"
         circuit_adjoint = qml.QNode(lambda x: circuit(x, wires=i_wires), dev, diff_method="adjoint")
         circuit_ps = qml.QNode(lambda x: circuit(x, wires=i_wires), dev, diff_method="parameter-shift")
         circuit_backprop = qml.QNode(lambda x: circuit(x, wires=i_wires), dev_python, diff_method="backprop")
@@ -66,7 +66,7 @@ def layers_scaling(n_wires, n_layers):
 
     dev = qml.device("lightning.qubit", wires=n_wires)
     dev_python = qml.device("default.qubit", wires=n_wires)
-
+"lightning.qubit"
     t_adjoint = []
     t_ps = []
     t_backprop = []
diff --git a/demonstrations_v2/ahs_aquila/demo.py b/demonstrations_v2/ahs_aquila/demo.py
index 896ae61cfa..70daf79549 100644
--- a/demonstrations_v2/ahs_aquila/demo.py
+++ b/demonstrations_v2/ahs_aquila/demo.py
@@ -521,7 +521,7 @@ def gaussian_fn(p, t):
 ts = [0.0, 1.75]
 
 default_qubit = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @qml.set_shots(1000)
 @qml.qnode(default_qubit, interface="jax")
diff --git a/demonstrations_v2/braket-parallel-gradients/demo.py b/demonstrations_v2/braket-parallel-gradients/demo.py
index 98dff6b077..0c9fba509c 100644
--- a/demonstrations_v2/braket-parallel-gradients/demo.py
+++ b/demonstrations_v2/braket-parallel-gradients/demo.py
@@ -116,7 +116,7 @@
 # execution on SV1 for gradient calculations. We'll also load ``default.qubit`` for comparison.
 
 dev_local = qml.device("default.qubit", wires=n_wires)
-
+"lightning.qubit"
 ##############################################################################
 # Note that a local Braket device ``braket.local.qubit`` is also available. See the
 # `documentation <https://amazon-braket-pennylane-plugin-python.readthedocs.io>`__ for more details.
diff --git a/demonstrations_v2/gqe_training/demo.py b/demonstrations_v2/gqe_training/demo.py
index 05d795a9cc..2ea42bf29f 100644
--- a/demonstrations_v2/gqe_training/demo.py
+++ b/demonstrations_v2/gqe_training/demo.py
@@ -175,7 +175,7 @@ def generate_molecule_data(molecules="H2"):
 # 
 
 dev = qml.device("default.qubit", wires=num_qubits)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def energy_circuit(gqe_ops):
     # Computes Eq. 1 from Nakaji et al. based on the selected unitary operators
diff --git a/demonstrations_v2/how_to_use_qiskit1_with_pennylane/demo.py b/demonstrations_v2/how_to_use_qiskit1_with_pennylane/demo.py
index 38d7355ed0..5d39688c16 100644
--- a/demonstrations_v2/how_to_use_qiskit1_with_pennylane/demo.py
+++ b/demonstrations_v2/how_to_use_qiskit1_with_pennylane/demo.py
@@ -45,7 +45,7 @@
 #   qml.device("shortname", *device_options)
 #
 # If you’ve
-# seen PennyLane code before, you’ve probably seen ``"default.qubit"`` or ``"lightning.qubit"`` as
+# seen PennyLane code before, you’ve probably seen ``"lightning.qubit"`` or ``"lightning.qubit"`` as
 # short names for our Python and C++ statevector simulators, respectively.
 #
 # In the PennyLane-Qiskit plugin, there are `many IBM
@@ -264,7 +264,7 @@ def qiskit_GHZ_circuit(n):
 pl_qfunc = qml.from_qiskit(qc, measurements=measurements)
 
 pl_circuit = qml.QNode(pl_qfunc, device=qml.device("default.qubit", wires=n))
-print(qml.set_shots(pl_circuit, shots=5)())
+print(qml.set_shots(pl_circuit, shots=5)())"lightning.qubit"
 
 ######################################################################
 # .. rst-class:: sphx-glr-script-out
diff --git a/demonstrations_v2/ibm_pennylane/demo.py b/demonstrations_v2/ibm_pennylane/demo.py
index 1452518ecb..b09fa5bf88 100644
--- a/demonstrations_v2/ibm_pennylane/demo.py
+++ b/demonstrations_v2/ibm_pennylane/demo.py
@@ -246,7 +246,7 @@ def cost_fn(theta):
 
 dev1 = qml.device("default.qubit", wires=4)
 shots = 8000
-dev2 = qml.device("qiskit.aer", wires=4)
+dev2 = qml.device("lightning.qubit"ires=4)
 
 
 @qml.qnode(dev1)
@@ -344,7 +344,7 @@ def cost_fn_2(theta):
 
 plt.plot(energies_1, color="r", label="default.qubit")
 plt.plot(energies_2, color="b", label="qiskit.aer")
-
+"lightning.qubit"
 # min energy = min eigenvalue
 min_energy = min(qml.eigvals(H))
 z = [min_energy] * max_iterations
diff --git a/demonstrations_v2/learning2learn/demo.py b/demonstrations_v2/learning2learn/demo.py
index 5c14d5ad68..8b8de1d8ef 100644
--- a/demonstrations_v2/learning2learn/demo.py
+++ b/demonstrations_v2/learning2learn/demo.py
@@ -245,7 +245,7 @@ def hamiltonian(params, **kwargs):
         """Evaluate the cost Hamiltonian, given the angles and the graph."""
 
         dev = qml.device("default.qubit", wires=len(graph.nodes))
-
+"lightning.qubit"
         # This qnode evaluates the expectation value of the cost hamiltonian operator
         cost = qml.QNode(circuit, dev, diff_method="backprop", interface="tf")
 
diff --git a/demonstrations_v2/ml_classical_shadows/demo.py b/demonstrations_v2/ml_classical_shadows/demo.py
index bbff01acec..be7b27f999 100644
--- a/demonstrations_v2/ml_classical_shadows/demo.py
+++ b/demonstrations_v2/ml_classical_shadows/demo.py
@@ -187,7 +187,7 @@ def corr_function(i, j):
 #
 
 dev_exact = qml.device("default.qubit", wires=num_qubits) # for exact simulation
-
+"lightning.qubit"
 def circuit(psi, observables):
     psi = psi / np.linalg.norm(psi) # normalize the state
     qml.StatePrep(psi, wires=range(num_qubits))
@@ -285,7 +285,7 @@ def build_exact_corrmat(coups, corrs, circuit, psi):
 #
 
 dev_oshot = qml.device("default.qubit", wires=num_qubits)
-circuit_oshot = qml.set_shots(qml.QNode(circuit, dev_oshot), shots = 1)
+circuit_oshot = qml.set"lightning.qubit"e(circuit, dev_oshot), shots = 1)
 
 
 ######################################################################
diff --git a/demonstrations_v2/oqc_pulse/demo.py b/demonstrations_v2/oqc_pulse/demo.py
index e2289bd640..339d4ec2ac 100644
--- a/demonstrations_v2/oqc_pulse/demo.py
+++ b/demonstrations_v2/oqc_pulse/demo.py
@@ -111,7 +111,7 @@ def wrapped(p, t):
 # Hamiltonian H.
 @jax.jit
 @qml.qnode(qml.device("default.qubit", wires=1), interface="jax")
-def trajectory(params, t):
+def trajectory(params,"lightning.qubit"
     qml.evolve(H)((params,), t, return_intermediate=True)
     return [qml.expval(op) for op in [X, Y, Z]]
 
@@ -163,7 +163,7 @@ def wrapped(p, t):
 # return_intermediate=False is the default, so we dont have to set it explicitly.
 @jax.jit
 @qml.qnode(qml.device("default.qubit", wires=1), interface="jax")
-def trajectory(Omega0, phi):
+def trajectory(Omega0,"lightning.qubit"
     qml.evolve(H1)([[Omega0, phi]], 20.0)
     return [qml.expval(op) for op in [X, Y, Z]]
 
@@ -218,7 +218,7 @@ def trajectory(Omega0, phi):
 
 wire = 5
 dev_sim = qml.device("default.qubit", wires=[wire])
-dev_lucy = qml.device(
+dev_lucy = qml.device"lightning.qubit"
     "braket.aws.qubit",
     device_arn="arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy",
     wires=range(8))
diff --git a/demonstrations_v2/plugins_hybrid/demo.py b/demonstrations_v2/plugins_hybrid/demo.py
index 600fbca71a..62a6fae281 100644
--- a/demonstrations_v2/plugins_hybrid/demo.py
+++ b/demonstrations_v2/plugins_hybrid/demo.py
@@ -305,7 +305,7 @@ def cost(params):
 
 # create the devices
 dev_qubit = qml.device("default.qubit", wires=1)
-dev_fock = qml.device("strawberryfields.fock", wires=2, cutoff_dim=10)
+dev_fock = qml.device(""lightning.qubit"s.fock", wires=2, cutoff_dim=10)
 
 
 @qml.qnode(dev_qubit, interface="autograd")
diff --git a/demonstrations_v2/qnn_module_tf/demo.py b/demonstrations_v2/qnn_module_tf/demo.py
index e04993f90e..6bde4c45ff 100644
--- a/demonstrations_v2/qnn_module_tf/demo.py
+++ b/demonstrations_v2/qnn_module_tf/demo.py
@@ -98,7 +98,7 @@
 
 n_qubits = 2
 dev = qml.device("default.qubit", wires=n_qubits)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def qnode(inputs, weights):
     qml.AngleEmbedding(inputs, wires=range(n_qubits))
diff --git a/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_JAXopt/demo.py b/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_JAXopt/demo.py
index 975e5dd03a..941c44aa73 100644
--- a/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_JAXopt/demo.py
+++ b/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_JAXopt/demo.py
@@ -42,7 +42,7 @@
 targets = jnp.array([-0.2, 0.4, 0.35, 0.2])
 
 dev = qml.device("default.qubit", wires=n_wires)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit(data, weights):
     """Quantum circuit ansatz"""
diff --git a/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_Optax/demo.py b/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_Optax/demo.py
index 19c1b684cd..92bd8d528a 100644
--- a/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_Optax/demo.py
+++ b/demonstrations_v2/tutorial_How_to_optimize_QML_model_using_JAX_and_Optax/demo.py
@@ -41,7 +41,7 @@
 targets = jnp.array([-0.2, 0.4, 0.35, 0.2])
 
 dev = qml.device("default.qubit", wires=n_wires)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit(data, weights):
     """Quantum circuit ansatz"""
diff --git a/demonstrations_v2/tutorial_QUBO/demo.py b/demonstrations_v2/tutorial_QUBO/demo.py
index f6e8bcb563..2956b132c6 100644
--- a/demonstrations_v2/tutorial_QUBO/demo.py
+++ b/demonstrations_v2/tutorial_QUBO/demo.py
@@ -353,7 +353,7 @@ def time_to_solution(n, time_single_case):
 
 shots = 5000  # Number of samples used
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.set_shots(shots)
 @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_adaptive_circuits/demo.py b/demonstrations_v2/tutorial_adaptive_circuits/demo.py
index 743aa2d4b3..260a270c1c 100644
--- a/demonstrations_v2/tutorial_adaptive_circuits/demo.py
+++ b/demonstrations_v2/tutorial_adaptive_circuits/demo.py
@@ -120,7 +120,7 @@
 # value of the Hamiltonian. We also need to define a device.
 
 hf_state = qchem.hf_state(active_electrons, qubits)
-dev = qml.device("default.qubit", wires=qubits)
+dev = qml.device("lightning.qubit", wires=qubits)
 @qml.qnode(dev)
 def circuit():
     [qml.PauliX(i) for i in np.nonzero(hf_state)[0]]
diff --git a/demonstrations_v2/tutorial_adjoint_diff/demo.py b/demonstrations_v2/tutorial_adjoint_diff/demo.py
index a95a269490..3caf3a2ca5 100644
--- a/demonstrations_v2/tutorial_adjoint_diff/demo.py
+++ b/demonstrations_v2/tutorial_adjoint_diff/demo.py
@@ -78,7 +78,7 @@
 #
 
 dev = qml.device("default.qubit", wires=2)
-
+"lightning.qubit"
 x = pnp.array([0.1, 0.2, 0.3], requires_grad=True)
 
 @qml.qnode(dev, diff_method="adjoint")
@@ -387,7 +387,7 @@ def circuit(a):
 # If you want to use adjoint differentiation without having to code up your own
 # method that can support arbitrary circuits, you can use ``diff_method="adjoint"`` in PennyLane with
 # ``"default.qubit"`` or PennyLane's fast C++ simulator ``"lightning.qubit"``.
-
+"lightning.qubit"
 
 dev_lightning = qml.device("lightning.qubit", wires=2)
 
@@ -422,7 +422,7 @@ def circuit_adjoint(a):
 # But how fast? The provided script `here <https://pennylane.ai/qml/demos/adjoint_diff_benchmarking>`__
 # generated the following images on a mid-range laptop.
 # The backpropagation times were produced with the Python simulator ``"default.qubit"``, while parameter-shift
-# and adjoint differentiation times were calculated with ``"lightning.qubit"``.
+# and adjoint differentiation times were calculated with ``"lightning."lightning.qubit"
 # The adjoint method clearly wins out for performance.
 #
 # .. figure:: ../_static/demonstration_assets/adjoint_diff/scaling.png
diff --git a/demonstrations_v2/tutorial_annni/demo.py b/demonstrations_v2/tutorial_annni/demo.py
index b052261ee1..72aef9634a 100644
--- a/demonstrations_v2/tutorial_annni/demo.py
+++ b/demonstrations_v2/tutorial_annni/demo.py
@@ -266,7 +266,7 @@ def pool(wires, params, index):
 
 num_params, output_wires = qcnn_ansatz(num_qubits, [0]*100)
 
-@qml.qnode(qml.device("default.qubit", wires=num_qubits))
+@qml.qnode(qml.device("lightning.qubit", wires=num_qubits))
 def qcnn_circuit(params, state):
     """QNode with QCNN ansatz and probabilities of unmeasured qubits as output"""
     # Input ground state from diagonalization
@@ -488,7 +488,7 @@ def block(nontrash, trash, shift):
 
 num_anomaly_params, trash_wires = qcnn_ansatz(num_qubits, [0]*100)
 
-@qml.qnode(qml.device("default.qubit", wires=num_qubits))
+@qml.qnode(qml.device("lightning.qubit", wires=num_qubits))
 def anomaly_circuit(params, state):
     """QNode with QAD ansatz and expectation values of the trash wires as output"""
     # Input ground state from diagonalization
diff --git a/demonstrations_v2/tutorial_apply_qsvt/demo.py b/demonstrations_v2/tutorial_apply_qsvt/demo.py
index ad59ee52d0..7e21d5b231 100644
--- a/demonstrations_v2/tutorial_apply_qsvt/demo.py
+++ b/demonstrations_v2/tutorial_apply_qsvt/demo.py
@@ -351,7 +351,7 @@ def real_u(A, phi):
 
 
 @qml.qnode(qml.device("default.qubit", wires=["ancilla1", "ancilla2", 0, 1, 2]))
-def linear_system_solver_circuit(phi):
+def linear_system_solv"lightning.qubit":
     qml.StatePrep(normalized_b, wires=[1, 2])
     real_u(A.T, phi)  # invert the singular values of A transpose to get A^-1
     return qml.state()
diff --git a/demonstrations_v2/tutorial_backprop/demo.py b/demonstrations_v2/tutorial_backprop/demo.py
index 566e25f67a..40dfa26c34 100644
--- a/demonstrations_v2/tutorial_backprop/demo.py
+++ b/demonstrations_v2/tutorial_backprop/demo.py
@@ -66,7 +66,7 @@
 
 # create a device to execute the circuit on
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 def CNOT_ring(wires):
     """Apply CNOTs in a ring pattern"""
@@ -177,7 +177,7 @@ def parameter_shift(qnode, params):
 # to make a more complicated QNode.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 @qml.qnode(dev, diff_method="parameter-shift")
 def circuit(params):
     qml.StronglyEntanglingLayers(params, wires=[0, 1, 2, 3])
@@ -269,7 +269,7 @@ def circuit(params):
 # In this demo, we will use the JAX interface.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 ##############################################################################
 # When defining the QNode, we specify ``diff_method="backprop"`` to ensure that
 # we are using backpropagation mode. Note that this is the *default differentiation
@@ -321,7 +321,7 @@ def circuit(params):
 # computation as the number of layers is allowed to increase.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 def circuit(params):
     qml.StronglyEntanglingLayers(params, wires=[0, 1, 2, 3])
     return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1) @ qml.PauliZ(2) @ qml.PauliZ(3))
diff --git a/demonstrations_v2/tutorial_barren_gadgets/demo.py b/demonstrations_v2/tutorial_barren_gadgets/demo.py
index 5041d40da3..7150882c35 100644
--- a/demonstrations_v2/tutorial_barren_gadgets/demo.py
+++ b/demonstrations_v2/tutorial_barren_gadgets/demo.py
@@ -247,7 +247,7 @@
 
 
 @qml.qnode(qml.device("default.qubit", wires=range(5)))
-def display_circuit(weights):
+def display_circuit(we"lightning.qubit"
     build_ansatz(initial_layer_weights=init_weights, weights=weights, wires=range(5))
     return qml.expval(qml.PauliZ(wires=0))
 
@@ -278,7 +278,7 @@ def display_circuit(weights):
 opt = qml.GradientDescentOptimizer(stepsize=0.1)
 max_iter = 500
 dev = qml.device("default.qubit", wires=range(num_qubits))
-
+"lightning.qubit"
 ##############################################################################
 # Finally, we will use two cost functions and create a
 # `QNode <https://docs.pennylane.ai/en/stable/code/api/pennylane.QNode.html>`_ for each.
diff --git a/demonstrations_v2/tutorial_barren_plateaus/demo.py b/demonstrations_v2/tutorial_barren_plateaus/demo.py
index 52ead15cc0..f14126241c 100644
--- a/demonstrations_v2/tutorial_barren_plateaus/demo.py
+++ b/demonstrations_v2/tutorial_barren_plateaus/demo.py
@@ -88,7 +88,7 @@
 
 num_qubits = 4
 dev = qml.device("default.qubit", wires=num_qubits)
-gate_set = [qml.RX, qml.RY, qml.RZ]
+gate_set = [qml.R"lightning.qubit"RZ]
 
 
 def rand_circuit(params, random_gate_sequence=None, num_qubits=None):
@@ -159,7 +159,7 @@ def rand_circuit(params, random_gate_sequence=None, num_qubits=None):
     grad_vals = []
     for i in range(num_samples):
         dev = qml.device("default.qubit", wires=num_qubits)
-        qcircuit = qml.QNode(rand_circuit, dev, interface="autograd")
+        qcircuit = qml.QN"lightning.qubit"t, dev, interface="autograd")
         grad = qml.grad(qcircuit, argnums=0)
 
         gate_set = [qml.RX, qml.RY, qml.RZ]
diff --git a/demonstrations_v2/tutorial_block_encoding/demo.py b/demonstrations_v2/tutorial_block_encoding/demo.py
index 4745ae0a52..3ef11a4559 100644
--- a/demonstrations_v2/tutorial_block_encoding/demo.py
+++ b/demonstrations_v2/tutorial_block_encoding/demo.py
@@ -325,7 +325,7 @@ def UB(wires_i, wires_j):
 # We now construct our circuit to block encode the sparse matrix and draw it.
 
 dev = qml.device("default.qubit", wires=(ancilla_wires + wires_i + wires_j))
-
+"lightning.qubit"
 @qml.qnode(dev)
 def complete_circuit(thetas):
     HN(wires_i)
diff --git a/demonstrations_v2/tutorial_circuit_compilation/demo.py b/demonstrations_v2/tutorial_circuit_compilation/demo.py
index 20efc5e028..fadb86624b 100644
--- a/demonstrations_v2/tutorial_circuit_compilation/demo.py
+++ b/demonstrations_v2/tutorial_circuit_compilation/demo.py
@@ -48,7 +48,7 @@
 import matplotlib.pyplot as plt
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 def circuit(angles):
     qml.Hadamard(wires=1)
diff --git a/demonstrations_v2/tutorial_clifford_circuit_simulations/demo.py b/demonstrations_v2/tutorial_clifford_circuit_simulations/demo.py
index c1985f3387..257a089fdb 100644
--- a/demonstrations_v2/tutorial_clifford_circuit_simulations/demo.py
+++ b/demonstrations_v2/tutorial_clifford_circuit_simulations/demo.py
@@ -411,7 +411,7 @@ def state_at_each_step(tape):
 # Let's see this in action for the following two-qubit parameterized circuit:
 #
 
-dev = qml.device("default.qubit")
+dev = qml.device("lightning.qubit")
 @qml.qnode(dev)
 def original_circuit(x, y):
     qml.RX(x, 0)
diff --git a/demonstrations_v2/tutorial_coherent_vqls/demo.py b/demonstrations_v2/tutorial_coherent_vqls/demo.py
index 5852af3bdc..dee1aec090 100644
--- a/demonstrations_v2/tutorial_coherent_vqls/demo.py
+++ b/demonstrations_v2/tutorial_coherent_vqls/demo.py
@@ -358,7 +358,7 @@ def full_circuit(weights):
 # we initialize a ``default.qubit`` device and we define two different ``qnode`` circuits.
 
 dev = qml.device("default.qubit", wires=tot_qubits)
-
+"lightning.qubit"
 @qml.qnode(dev, interface="autograd")
 def global_ground(weights):
     # Circuit gates
@@ -486,7 +486,7 @@ def cost(weights):
 # QNode.
 
 dev_x = qml.device("default.qubit", wires=n_qubits)
-
+"lightning.qubit"
 @qml.set_shots(n_shots)
 @qml.qnode(dev_x, interface="autograd")
 def prepare_and_sample(weights):
diff --git a/demonstrations_v2/tutorial_constant_depth_mps_prep/demo.py b/demonstrations_v2/tutorial_constant_depth_mps_prep/demo.py
index 7fb9eb8944..bac0b7b06a 100644
--- a/demonstrations_v2/tutorial_constant_depth_mps_prep/demo.py
+++ b/demonstrations_v2/tutorial_constant_depth_mps_prep/demo.py
@@ -340,8 +340,7 @@ def project_measure(wire_0, wire_1):
     qml.measure(wire_1, postselect=0)
 
 
-dev = qml.device("default.qubit")
-
+dev = qml.device("lightning.qubit")
 
 @qml.qnode(dev)
 def sequential_circuit(N, g):
@@ -491,7 +490,7 @@ def two_qubit_mps_by_fusion(g):
 # MPS already, the test measurement would just be :math:`\langle 00 | Z_0| 00\rangle=1.`
 
 
-@qml.qnode(qml.device("default.qubit", wires=6))
+@qml.qnode(qml.device("lightning.qubit", wires=6))
 def prepare_and_unprepare(g):
     two_qubit_mps_by_fusion(g)
     # The bond qubits for a sequential preparation are just 0 and 5
diff --git a/demonstrations_v2/tutorial_contextuality/demo.py b/demonstrations_v2/tutorial_contextuality/demo.py
index 4771bf6e24..725f284db0 100644
--- a/demonstrations_v2/tutorial_contextuality/demo.py
+++ b/demonstrations_v2/tutorial_contextuality/demo.py
@@ -508,7 +508,7 @@ def bias_inv_layer(weights, x):
 #
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def model(weights, x):
@@ -542,7 +542,7 @@ def generic_layer(weights, x):
 
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def generic_model(weights, x):
diff --git a/demonstrations_v2/tutorial_diffable_shadows/demo.py b/demonstrations_v2/tutorial_diffable_shadows/demo.py
index 94a7aacef4..4f540f8320 100644
--- a/demonstrations_v2/tutorial_diffable_shadows/demo.py
+++ b/demonstrations_v2/tutorial_diffable_shadows/demo.py
@@ -103,7 +103,7 @@
 H = qml.Hamiltonian([1., 1.], [qml.PauliZ(0) @ qml.PauliZ(1), qml.PauliX(0) @ qml.PauliX(1)])
 
 dev = qml.device("default.qubit", wires=range(2))
-@qml.set_shots(10000)
+@qml.set_shots(10"lightning.qubit"
 @qml.qnode(dev, interface="autograd")
 def qnode(x, H):
     qml.Hadamard(0)
@@ -131,7 +131,7 @@ def qnode(x, H):
 # class methods.
 
 dev = qml.device("default.qubit", wires=range(2))
-@qml.set_shots(1000)
+@qml.set_shots(10"lightning.qubit"
 @qml.qnode(dev, interface="autograd")
 def qnode(x):
     qml.Hadamard(0)
@@ -196,7 +196,7 @@ def circuit():
 obs = qml.PauliX(0) @ qml.PauliZ(3) @ qml.PauliX(6) @ qml.PauliZ(7)
 
 dev_ideal = qml.device("default.qubit", wires=range(n_wires))
-@qml.qnode(dev_ideal, interface="autograd")
+@qml.qnode(dev_ideal, i"lightning.qubit"rad")
 def qnode_ideal():
     circuit()
     return qml.expval(obs)
@@ -213,7 +213,7 @@ def qnode_ideal():
     for _ in range(10):
         # repeating experiment 10 times to obtain averages and standard deviations
         dev = qml.device("default.qubit", wires=range(10))
-
+"lightning.qubit"
         @qml.set_shots(shots)
         @qml.qnode(dev, interface="autograd")
         def qnode_finite():
@@ -284,7 +284,7 @@ def qnode_shadow():
 n_groups = len(qml.pauli.group_observables(all_observables))
 
 dev_ideal = qml.device("default.qubit", wires=range(n))
-
+"lightning.qubit"
 x = np.random.rand(n*2)
 def circuit():
     for i in range(n):
@@ -322,7 +322,7 @@ def qnode_ideal():
 
     for _ in range(10):
         dev = qml.device("default.qubit", wires=range(5))
-
+"lightning.qubit"
         @qml.set_shots(shots)
         @qml.qnode(dev, interface="autograd")
         def qnode_finite():
@@ -330,7 +330,7 @@ def qnode_finite():
             return qml.expval(H)
 
         dev = qml.device("default.qubit", wires=range(5))
-        @qml.set_shots(shots*n_groups)
+        @qml.set_shots(sh"lightning.qubit"
         @qml.qnode(dev, interface="autograd")
         def qnode_shadow():
             circuit()
@@ -423,7 +423,7 @@ def circuit():
 
         # execute qwc measurements
         dev_finite = qml.device("default.qubit", wires=range(n_wires))
-
+"lightning.qubit"
         @qml.set_shots(int(shots))
         @qml.qnode(dev_finite, interface="autograd")
         def qnode_finite(H):
@@ -435,7 +435,7 @@ def qnode_finite(H):
 
         # execute shadows measurements
         dev_shadow = qml.device("default.qubit", wires=range(n_wires))
-        @qml.set_shots(int(shots)*n_groups)
+        @qml.set_shots(int(shots"lightning.qubit"
         @qml.qnode(dev_shadow, interface="autograd")
         def qnode():
             circuit()
diff --git a/demonstrations_v2/tutorial_differentiable_HF/demo.py b/demonstrations_v2/tutorial_differentiable_HF/demo.py
index 0d89ef58b5..9d402e6e74 100644
--- a/demonstrations_v2/tutorial_differentiable_HF/demo.py
+++ b/demonstrations_v2/tutorial_differentiable_HF/demo.py
@@ -264,7 +264,7 @@
 # hydrogen atoms.
 
 dev = qml.device("default.qubit", wires=4)
-def energy():
+def energy():"lightning.qubit"
     @qml.qnode(dev, interface="jax")
     def circuit(*args):
         qml.BasisState(np.array([1, 1, 0, 0]), wires=range(4))
diff --git a/demonstrations_v2/tutorial_dqi/demo.py b/demonstrations_v2/tutorial_dqi/demo.py
index a05e62f8cd..f427e0f893 100644
--- a/demonstrations_v2/tutorial_dqi/demo.py
+++ b/demonstrations_v2/tutorial_dqi/demo.py
@@ -340,7 +340,7 @@ def prepare_dicke_state(m, k):
 
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def weight_error_prep(m, n, l):
diff --git a/demonstrations_v2/tutorial_eqnn_force_field/demo.py b/demonstrations_v2/tutorial_eqnn_force_field/demo.py
index 2185f2f9be..b993bf2bc3 100644
--- a/demonstrations_v2/tutorial_eqnn_force_field/demo.py
+++ b/demonstrations_v2/tutorial_eqnn_force_field/demo.py
@@ -302,7 +302,7 @@ def noise_layer(epsilon, wires):
 
 
 dev = qml.device("default.qubit", wires=num_qubits)
-
+"lightning.qubit"
 
 @qml.qnode(dev, interface="jax")
 def vqlm(data, params):
diff --git a/demonstrations_v2/tutorial_error_mitigation/demo.py b/demonstrations_v2/tutorial_error_mitigation/demo.py
index 0c0b04cead..d3db4284ea 100644
--- a/demonstrations_v2/tutorial_error_mitigation/demo.py
+++ b/demonstrations_v2/tutorial_error_mitigation/demo.py
@@ -450,7 +450,7 @@ def executor(circuits, dev=dev_noisy):
 n_wires = 4
 
 dev_ideal = qml.device("default.qubit", wires=n_wires)
-dev_noisy = qml.device(
+dev_noisy = qml.device("lightning.qubit"
     "qiskit.aer",
     wires=n_wires,
     noise_model=noise_model,
diff --git a/demonstrations_v2/tutorial_error_prop/demo.py b/demonstrations_v2/tutorial_error_prop/demo.py
index 7a431fdf0f..bf46b68b81 100644
--- a/demonstrations_v2/tutorial_error_prop/demo.py
+++ b/demonstrations_v2/tutorial_error_prop/demo.py
@@ -187,7 +187,7 @@ def error(self):
 # the circuit. This means we can write our circuits as usual and get all the benefits of error tracking for free.
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circ(H, t, phi1, phi2):
diff --git a/demonstrations_v2/tutorial_expressivity_fourier_series/demo.py b/demonstrations_v2/tutorial_expressivity_fourier_series/demo.py
index 3a6c16c711..1c49393742 100644
--- a/demonstrations_v2/tutorial_expressivity_fourier_series/demo.py
+++ b/demonstrations_v2/tutorial_expressivity_fourier_series/demo.py
@@ -274,7 +274,7 @@ def target_function(x):
 scaling = 1
 
 dev = qml.device("default.qubit", wires=1)
-
+"lightning.qubit"
 
 def S(x):
     """Data-encoding circuit block."""
@@ -494,7 +494,7 @@ def cost(weights, x, y):
 n_qubits = 3
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def ansatz(weights):
@@ -514,7 +514,7 @@ def ansatz(weights):
 r = 3
 
 dev = qml.device("default.qubit", wires=r)
-
+"lightning.qubit"
 
 def S(x):
     """Data-encoding circuit block."""
@@ -676,7 +676,7 @@ def fourier_coefficients(f, K):
 n_qubits = 4
 
 dev = qml.device("default.qubit", wires=n_qubits)
-
+"lightning.qubit"
 
 def S(x):
     """Data encoding circuit block."""
diff --git a/demonstrations_v2/tutorial_falqon/demo.py b/demonstrations_v2/tutorial_falqon/demo.py
index 0fa9993723..1ccc4f754a 100644
--- a/demonstrations_v2/tutorial_falqon/demo.py
+++ b/demonstrations_v2/tutorial_falqon/demo.py
@@ -278,7 +278,7 @@ def max_clique_falqon(graph, n, beta_1, delta_t, dev):
 delta_t = 0.03
 
 dev = qml.device("default.qubit", wires=graph.nodes) # Creates a device for the simulation
-res_beta, res_energies = max_clique_falqon(graph, n, beta_1, delta_t, dev)
+res_beta, res_ene"lightning.qubit"que_falqon(graph, n, beta_1, delta_t, dev)
 
 ######################################################################
 # We can then plot the expectation value of the cost Hamiltonian over the
@@ -407,7 +407,7 @@ def prob_circuit():
 
 depth = 5
 dev = qml.device("default.qubit", wires=new_graph.nodes)
-
+"lightning.qubit"
 # Creates the cost and mixer Hamiltonians
 cost_h, mixer_h = qaoa.max_clique(new_graph, constrained=False)
 
diff --git a/demonstrations_v2/tutorial_general_parshift/demo.py b/demonstrations_v2/tutorial_general_parshift/demo.py
index 533a6d085f..7c92d5c4cc 100644
--- a/demonstrations_v2/tutorial_general_parshift/demo.py
+++ b/demonstrations_v2/tutorial_general_parshift/demo.py
@@ -133,8 +133,7 @@ def random_observable(N, seed):
 
 def make_cost(N, seed):
     """Create a cost function on N qubits with N frequencies."""
-    dev = qml.device("default.qubit", wires=N)
-
+    dev = qml.device("lightning.qubit", wires=N)
     @jax.jit
     @qml.qnode(dev, interface="jax")
     def cost(x):
diff --git a/demonstrations_v2/tutorial_geometric_qml/demo.py b/demonstrations_v2/tutorial_geometric_qml/demo.py
index 845476eb21..05bf397290 100644
--- a/demonstrations_v2/tutorial_geometric_qml/demo.py
+++ b/demonstrations_v2/tutorial_geometric_qml/demo.py
@@ -498,7 +498,7 @@ def create_dataset(size_for_each_winner):
 
 # Set up a nine-qubit system
 dev = qml.device("default.qubit", wires=9)
-
+"lightning.qubit"
 ob_center = qml.PauliZ(4)
 ob_corner = (qml.PauliZ(0) + qml.PauliZ(2) + qml.PauliZ(6) + qml.PauliZ(8)) * (1 / 4)
 ob_edge = (qml.PauliZ(1) + qml.PauliZ(3) + qml.PauliZ(5) + qml.PauliZ(7)) * (1 / 4)
diff --git a/demonstrations_v2/tutorial_grovers_algorithm/demo.py b/demonstrations_v2/tutorial_grovers_algorithm/demo.py
index c3a0fa0431..ece72c6508 100644
--- a/demonstrations_v2/tutorial_grovers_algorithm/demo.py
+++ b/demonstrations_v2/tutorial_grovers_algorithm/demo.py
@@ -69,7 +69,7 @@
 
 NUM_QUBITS = 2
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-wires = list(range(NUM_QUBITS))
+wires = list(rang"lightning.qubit"
 
 
 def equal_superposition(wires):
@@ -132,7 +132,7 @@ def circuit():
 # :math:`\vert 00 \rangle = \begin{bmatrix} 1 \\0 \\0 \\0 \end{bmatrix}` will flip:
 
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     qml.Snapshot("Initial state |00>")
@@ -173,7 +173,7 @@ def oracle(wires, omega):
     qml.FlipSign(omega, wires=wires)
 
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     equal_superposition(wires)
@@ -260,7 +260,7 @@ def circuit():
 
 
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-
+"lightning.qubit"
 
 def diffusion_operator(wires):
     for wire in wires:
@@ -319,7 +319,7 @@ def circuit():
 wires = list(range(NUM_QUBITS))
 
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     iterations = int(np.round(np.sqrt(N / M) * np.pi / 4))
diff --git a/demonstrations_v2/tutorial_guide_to_pennylane_knowing_qiskit/demo.py b/demonstrations_v2/tutorial_guide_to_pennylane_knowing_qiskit/demo.py
index a73c64857c..00c88d8303 100644
--- a/demonstrations_v2/tutorial_guide_to_pennylane_knowing_qiskit/demo.py
+++ b/demonstrations_v2/tutorial_guide_to_pennylane_knowing_qiskit/demo.py
@@ -170,7 +170,7 @@ def pl_func():
 #
 
 dev = qml.device("default.qubit")
-pl_circuit = qml.set_shots(qml.QNode(pl_func, dev), shots = 1024)
+pl_circuit = qml."lightning.qubit"Node(pl_func, dev), shots = 1024)
 
 print(pl_circuit())
 
@@ -188,8 +188,8 @@ def pl_func():
 #   whose values are NumPy arrays.
 #
 # - **A device** (e.g., ``qml.device("default.qubit")``). PennyLane has `many devices you can choose from <https://pennylane.ai/plugins/#built-in-devices>`__, 
-#   but ``"default.qubit"`` is our battle-tested Python state vector simulator.
-#
+#   but ``"default.qubit"`` is our ba"lightning.qubit"hon state vector simulator.
+#"lightning.qubit"
 #
 # As for measurements in PennyLane, they are quite different from Qiskit's V2 primitives. 
 # :doc:`PennyLane's measurement API <introduction/measurements>` comprises ergonomic functions that a QNode 
diff --git a/demonstrations_v2/tutorial_here_comes_the_sun/demo.py b/demonstrations_v2/tutorial_here_comes_the_sun/demo.py
index 63cbe697c1..5bb7dbfe56 100644
--- a/demonstrations_v2/tutorial_here_comes_the_sun/demo.py
+++ b/demonstrations_v2/tutorial_here_comes_the_sun/demo.py
@@ -222,7 +222,7 @@
 jax.config.update("jax_platform_name", "cpu")
 jnp = jax.numpy
 
-dev = qml.device("default.qubit", wires=1)
+dev = qml.device("lightning.qubit", wires=1)
 H = 0.6 * qml.PauliZ(0) - 0.8 * qml.PauliY(0)
 
 
@@ -446,7 +446,7 @@ def two_qubit_decomp(params, wires):
 
 loc = 2
 d = loc**4 - 1  # d = 15 for two-qubit operations
-dev = qml.device("default.qubit", wires=num_wires)
+dev = qml.device("lightning.qubit", wires=num_wires)
 # two blocks with two layers. Each layer contains three operations with d parameters
 param_shape = (2, 2, 3, d)
 init_params = np.zeros(param_shape)
diff --git a/demonstrations_v2/tutorial_how_to_collect_mcm_stats/demo.py b/demonstrations_v2/tutorial_how_to_collect_mcm_stats/demo.py
index 31982228b0..6a259ab43f 100644
--- a/demonstrations_v2/tutorial_how_to_collect_mcm_stats/demo.py
+++ b/demonstrations_v2/tutorial_how_to_collect_mcm_stats/demo.py
@@ -77,7 +77,7 @@ def ansatz(x):
 #
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.set_shots(100)
 @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_how_to_create_dynamic_mcm_circuits/demo.py b/demonstrations_v2/tutorial_how_to_create_dynamic_mcm_circuits/demo.py
index a4d5b84ad7..8baa1861bc 100644
--- a/demonstrations_v2/tutorial_how_to_create_dynamic_mcm_circuits/demo.py
+++ b/demonstrations_v2/tutorial_how_to_create_dynamic_mcm_circuits/demo.py
@@ -103,7 +103,7 @@ def init_state(x):
 
 shots = 100
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.set_shots(shots)
 @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_how_to_use_quantum_arithmetic_operators/demo.py b/demonstrations_v2/tutorial_how_to_use_quantum_arithmetic_operators/demo.py
index 306e203429..1f1007564d 100644
--- a/demonstrations_v2/tutorial_how_to_use_quantum_arithmetic_operators/demo.py
+++ b/demonstrations_v2/tutorial_how_to_use_quantum_arithmetic_operators/demo.py
@@ -80,7 +80,7 @@ def product_basis_state(x=0,y=0):
     qml.BasisState(x, wires=wires["x"])
     qml.BasisState(y, wires=wires["y"])
 
-dev = qml.device("default.qubit")
+dev = qml.device("lightning.qubit")
 @qml.set_shots(1)
 @qml.qnode(dev)
 def circuit(x,y):
diff --git a/demonstrations_v2/tutorial_how_to_use_registers/demo.py b/demonstrations_v2/tutorial_how_to_use_registers/demo.py
index b200ee934a..d0680469ea 100644
--- a/demonstrations_v2/tutorial_how_to_use_registers/demo.py
+++ b/demonstrations_v2/tutorial_how_to_use_registers/demo.py
@@ -78,7 +78,7 @@
 swap_register = qml.registers({"auxiliary": 1, "psi": 3, "phi": 3})
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def swap_test():
     # Make "psi" and "phi" state orthogonal to each other
diff --git a/demonstrations_v2/tutorial_implicit_diff_susceptibility/demo.py b/demonstrations_v2/tutorial_implicit_diff_susceptibility/demo.py
index 70d76b60e9..6b08c331a5 100644
--- a/demonstrations_v2/tutorial_implicit_diff_susceptibility/demo.py
+++ b/demonstrations_v2/tutorial_implicit_diff_susceptibility/demo.py
@@ -437,7 +437,7 @@ def expval_A_exact(a):
 weights_shape = variational_ansatz.shape(n_layers, N)
 
 dev = qml.device("default.qubit", wires=N)
-
+"lightning.qubit"
 
 @jax.jit
 @qml.qnode(dev, interface="jax")
diff --git a/demonstrations_v2/tutorial_initial_state_preparation/demo.py b/demonstrations_v2/tutorial_initial_state_preparation/demo.py
index 0797a07a5b..00d12eaa43 100644
--- a/demonstrations_v2/tutorial_initial_state_preparation/demo.py
+++ b/demonstrations_v2/tutorial_initial_state_preparation/demo.py
@@ -230,7 +230,7 @@
 H2mol, qubits = qchem.molecular_hamiltonian(molecule)
 wires = list(range(qubits))
 dev = qml.device("default.qubit", wires=qubits)
-
+"lightning.qubit"
 # create all possible excitations in H3+
 singles, doubles = qchem.excitations(2, qubits)
 excitations = singles + doubles
diff --git a/demonstrations_v2/tutorial_intro_amplitude_amplification/demo.py b/demonstrations_v2/tutorial_intro_amplitude_amplification/demo.py
index 86d50f0ca1..54fe3c44cb 100644
--- a/demonstrations_v2/tutorial_intro_amplitude_amplification/demo.py
+++ b/demonstrations_v2/tutorial_intro_amplitude_amplification/demo.py
@@ -151,7 +151,7 @@ def U(wires):
         qml.Hadamard(wires=wire)
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     U(wires = range(n))
diff --git a/demonstrations_v2/tutorial_intro_qrom/demo.py b/demonstrations_v2/tutorial_intro_qrom/demo.py
index bbf3087ecf..7a73744d9f 100644
--- a/demonstrations_v2/tutorial_intro_qrom/demo.py
+++ b/demonstrations_v2/tutorial_intro_qrom/demo.py
@@ -72,7 +72,7 @@
 Ui = [qml.BasisState(int(bitstring, 2), target_wires) for bitstring in bitstrings]
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 # This line is included for drawing purposes only.
 @partial(qml.transforms.decompose, max_expansion=1)
@@ -226,7 +226,7 @@ def circuit(index):
 @partial(qml.transforms.decompose, max_expansion=2)
 @qml.set_shots(1)
 @qml.qnode(qml.device("default.qubit"))
-def circuit(index):
+def circuit(index):"lightning.qubit"
     qml.BasisState(index, wires=control_wires)
     qml.QROM(bitstrings, control_wires, target_wires, work_wires, clean=False)
     return qml.sample(wires=target_wires), qml.sample(wires=target_wires)
diff --git a/demonstrations_v2/tutorial_isingmodel_PyTorch/demo.py b/demonstrations_v2/tutorial_isingmodel_PyTorch/demo.py
index f113eed7aa..27ad46e6ea 100644
--- a/demonstrations_v2/tutorial_isingmodel_PyTorch/demo.py
+++ b/demonstrations_v2/tutorial_isingmodel_PyTorch/demo.py
@@ -50,7 +50,7 @@
 # A three-qubit quantum circuit is initialized to represent the three spins:
  
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 @qml.qnode(dev, interface="torch") 
 def circuit(p1, p2):
     # We use the general Rot(phi,theta,omega,wires) single-qubit operation
diff --git a/demonstrations_v2/tutorial_jax_transformations/demo.py b/demonstrations_v2/tutorial_jax_transformations/demo.py
index ec10ecbee2..4dd57cdcfd 100644
--- a/demonstrations_v2/tutorial_jax_transformations/demo.py
+++ b/demonstrations_v2/tutorial_jax_transformations/demo.py
@@ -48,7 +48,7 @@
 # Added to silence some warnings.
 jax.config.update("jax_enable_x64", True)
 
-dev = qml.device("default.qubit", wires=2)
+dev = qml.device("lightning.qubit", wires=2)
 
 ##############################################################################
 # Let's start with a simple example circuit that generates a two-qubit entangled state,
@@ -271,7 +271,7 @@ def circuit(param):
 @jax.jit
 def circuit(key, param):
     # Notice how the device construction now happens within the jitted method.
-    dev = qml.device("default.qubit", wires=2, seed=key)
+    dev = qml.device("lightning.qubit", wires=2, seed=key)
 
     # Now we can create our qnode within the circuit function.
     @qml.set_shots(10)
diff --git a/demonstrations_v2/tutorial_kernels_module/demo.py b/demonstrations_v2/tutorial_kernels_module/demo.py
index bdf8798a67..e7e52fa893 100644
--- a/demonstrations_v2/tutorial_kernels_module/demo.py
+++ b/demonstrations_v2/tutorial_kernels_module/demo.py
@@ -282,8 +282,8 @@ def random_params(num_wires, num_layers):
 # For the purpose of this tutorial we will use PennyLane's ``default.qubit``
 # device with 5 wires in analytic mode.
 
-dev = qml.device("default.qubit", wires=5)
-wires = dev.wires.tolist()
+dev = qml.device("lightning.qubit", wires=5)
+wires = dev.wires
 
 ##############################################################################
 # Let us now define the quantum circuit that realizes the kernel. We will compute
diff --git a/demonstrations_v2/tutorial_lcu_blockencoding/demo.py b/demonstrations_v2/tutorial_lcu_blockencoding/demo.py
index 49cee9c194..c3e1a55202 100644
--- a/demonstrations_v2/tutorial_lcu_blockencoding/demo.py
+++ b/demonstrations_v2/tutorial_lcu_blockencoding/demo.py
@@ -143,7 +143,7 @@
 # the normalized target state as input:
 
 dev1 = qml.device("default.qubit", wires=1)
-
+"lightning.qubit"
 # normalized square roots of coefficients
 alphas = (np.sqrt(LCU_coeffs) / np.linalg.norm(np.sqrt(LCU_coeffs)))
 
@@ -166,7 +166,7 @@ def prep_circuit():
 import matplotlib.pyplot as plt
 
 dev2 = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 # unitaries
 ops = LCU_ops
 # relabeling wires: 0 → 1, and 1 → 2
diff --git a/demonstrations_v2/tutorial_learning_dynamics_incoherently/demo.py b/demonstrations_v2/tutorial_learning_dynamics_incoherently/demo.py
index b21cea07ca..f4f9de9383 100644
--- a/demonstrations_v2/tutorial_learning_dynamics_incoherently/demo.py
+++ b/demonstrations_v2/tutorial_learning_dynamics_incoherently/demo.py
@@ -115,7 +115,7 @@
 #
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def target_circuit(input_state):
     # prepare training state
@@ -343,7 +343,7 @@ def cost(params):
 #
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def model_circuit(params, random_state):
     # this is a parameterized quantum circuit with the same gate structure as the target unitary
diff --git a/demonstrations_v2/tutorial_learning_few_data/demo.py b/demonstrations_v2/tutorial_learning_few_data/demo.py
index 4a4f9a51ce..e33def1d48 100644
--- a/demonstrations_v2/tutorial_learning_few_data/demo.py
+++ b/demonstrations_v2/tutorial_learning_few_data/demo.py
@@ -239,7 +239,7 @@ def dense_layer(weights, wires):
 
 num_wires = 6
 device = qml.device("default.qubit", wires=num_wires)
-
+"lightning.qubit"
 
 @qml.qnode(device)
 def conv_net(weights, last_layer_weights, features):
diff --git a/demonstrations_v2/tutorial_learningshallow/demo.py b/demonstrations_v2/tutorial_learningshallow/demo.py
index 664c50f6e5..79ad07c53a 100644
--- a/demonstrations_v2/tutorial_learningshallow/demo.py
+++ b/demonstrations_v2/tutorial_learningshallow/demo.py
@@ -60,7 +60,7 @@ def V_0():
     qml.Hadamard(0)
     
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def local_inversion():
     U_test()   # some shallow unitary circuit
@@ -345,7 +345,7 @@ def step(opt_state, theta):
     return thetas, energy
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 ##############################################################################
 # As a cost function, we perform state tomography after applying :math:`U^\text{target}` and our Ansatz :math:`V_i.`
 # Our aim is to bring the state on qubit ``i`` back to the north pole of the Bloch sphere, and we specify our cost function accordingly.
diff --git a/demonstrations_v2/tutorial_liesim/demo.py b/demonstrations_v2/tutorial_liesim/demo.py
index 1a04dbac6c..a79038a85c 100644
--- a/demonstrations_v2/tutorial_liesim/demo.py
+++ b/demonstrations_v2/tutorial_liesim/demo.py
@@ -267,7 +267,7 @@ def forward(theta):
 H = 0.5 * qml.sum(*[op.operation() for op in generators])
 
 @qml.qnode(qml.device("default.qubit"), interface="jax")
-def qnode(theta):
+def qnode(theta):"lightning.qubit"
     for i, mu in enumerate(gate_choice):
         qml.exp(-1j * theta[i] * dla[mu].operation())
     return qml.expval(H)
diff --git a/demonstrations_v2/tutorial_liesim_extension/demo.py b/demonstrations_v2/tutorial_liesim_extension/demo.py
index 177f0cd807..3117754730 100644
--- a/demonstrations_v2/tutorial_liesim_extension/demo.py
+++ b/demonstrations_v2/tutorial_liesim_extension/demo.py
@@ -302,7 +302,7 @@ def exppw(theta, ps):
 # As a sanity check, let us compare this to the same circuit but using our default state vector simulator in PennyLane.
 
 @qml.qnode(qml.device("default.qubit"))
-def true():
+def true():"lightning.qubit"
     qml.exp(-1j * theta * dla[-1].operation())
     qml.exp(-1j * 0.5 * p.operation())
     qml.exp(-1j * 0.5 * dla[-2].operation())
diff --git a/demonstrations_v2/tutorial_magic_state_distillation/demo.py b/demonstrations_v2/tutorial_magic_state_distillation/demo.py
index 0138e99d8c..c5597ad08e 100644
--- a/demonstrations_v2/tutorial_magic_state_distillation/demo.py
+++ b/demonstrations_v2/tutorial_magic_state_distillation/demo.py
@@ -247,7 +247,7 @@ def state_distillation(random_key, r):
 import os
 
 dev_5_qubits = qml.device("default.qubit", wires=5)
-
+"lightning.qubit"
 @jax.jit
 @qml.qnode(dev_5_qubits, interface="jax")
 def T0_state():
diff --git a/demonstrations_v2/tutorial_mapping/demo.py b/demonstrations_v2/tutorial_mapping/demo.py
index 7e7795f331..86d7e8d7a3 100644
--- a/demonstrations_v2/tutorial_mapping/demo.py
+++ b/demonstrations_v2/tutorial_mapping/demo.py
@@ -295,7 +295,7 @@
 params = jnp.array([0.22347661, 0.0, 0.0])
 
 dev = qml.device("default.qubit", wires=qubits)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit(params):
     qml.BasisState(hf_state, wires=range(qubits))
diff --git a/demonstrations_v2/tutorial_mcm_introduction/demo.py b/demonstrations_v2/tutorial_mcm_introduction/demo.py
index b9ad2b3101..c9c5b6796b 100644
--- a/demonstrations_v2/tutorial_mcm_introduction/demo.py
+++ b/demonstrations_v2/tutorial_mcm_introduction/demo.py
@@ -103,7 +103,7 @@
 # expectation values that will be insightful later on. We follow these steps:
 #
 # - Import PennyLane and define a device using :func:`~.pennylane.device`.
-#   The built-in ``"default.qubit"`` Python statevector simulator will suffice for our
+#   The built-in ``"lightning.qubit"`` Python statevector simulator will suffice for our
 #   purposes, however PennyLane provides a wide array of additional
 #   `high-performance and hardware devices <https://pennylane.ai/plugins/>`__.
 #
@@ -125,7 +125,7 @@
 import pennylane as qml
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def before():
     qml.Hadamard(0)  # Create |+> state
diff --git a/demonstrations_v2/tutorial_measurement_optimize/demo.py b/demonstrations_v2/tutorial_measurement_optimize/demo.py
index 83d218cc4f..c784c0e7ca 100644
--- a/demonstrations_v2/tutorial_measurement_optimize/demo.py
+++ b/demonstrations_v2/tutorial_measurement_optimize/demo.py
@@ -126,7 +126,7 @@
 
 # Create a 4 qubit simulator
 dev = qml.device("default.qubit", seed=904932)
-
+"lightning.qubit"
 # number of electrons
 electrons = 2
 
@@ -370,7 +370,7 @@ def cost_circuit(params):
 
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 @qml.qnode(dev, interface="jax")
 def circuit1(weights):
     qml.StronglyEntanglingLayers(weights, wires=range(3))
diff --git a/demonstrations_v2/tutorial_mol_geo_opt/demo.py b/demonstrations_v2/tutorial_mol_geo_opt/demo.py
index 91d6315eef..25dd6198e5 100644
--- a/demonstrations_v2/tutorial_mol_geo_opt/demo.py
+++ b/demonstrations_v2/tutorial_mol_geo_opt/demo.py
@@ -195,7 +195,7 @@ def H(x):
 # In this example, we use the ``default.qubit`` simulator:
 num_wires = 6
 dev = qml.device("default.qubit", wires=num_wires)
-
+"lightning.qubit"
 
 @qml.qnode(dev, interface="jax")
 def circuit(params, obs, wires):
diff --git a/demonstrations_v2/tutorial_multiclass_classification/demo.py b/demonstrations_v2/tutorial_multiclass_classification/demo.py
index 1acf359534..46a7af53d5 100644
--- a/demonstrations_v2/tutorial_multiclass_classification/demo.py
+++ b/demonstrations_v2/tutorial_multiclass_classification/demo.py
@@ -70,7 +70,7 @@
 total_iterations = 100
 
 dev = qml.device("default.qubit", wires=num_qubits)
-
+"lightning.qubit"
 
 #################################################################################
 # Quantum Circuit
diff --git a/demonstrations_v2/tutorial_neutral_atoms/demo.py b/demonstrations_v2/tutorial_neutral_atoms/demo.py
index b299941063..104aefab65 100644
--- a/demonstrations_v2/tutorial_neutral_atoms/demo.py
+++ b/demonstrations_v2/tutorial_neutral_atoms/demo.py
@@ -361,7 +361,7 @@ def blackman_window(peak, time):
 
 # For now, let's act on only one neutral atom
 single_qubit_dev = qml.device("default.qubit", wires=1)
-
+"lightning.qubit"
 
 @qml.qnode(single_qubit_dev)
 def state_evolution():
@@ -628,7 +628,7 @@ def pi_pulse(distance, coupling, wires=[0]):
 #
 
 dev_two_qubits = qml.device("default.qubit", wires=2)
-
+"lightning.qubit"
 
 @qml.qnode(dev_two_qubits)
 def neutral_atom_CZ(distance, coupling):
diff --git a/demonstrations_v2/tutorial_odegen/demo.py b/demonstrations_v2/tutorial_odegen/demo.py
index c7b4cc1e21..1c1904c05f 100644
--- a/demonstrations_v2/tutorial_odegen/demo.py
+++ b/demonstrations_v2/tutorial_odegen/demo.py
@@ -231,7 +231,7 @@ def qnode0(params):
     return qml.expval(H_obj)
 
 dev = qml.device("default.qubit", wires=range(2))
-
+"lightning.qubit"
 qnode_jax = qml.QNode(qnode0, dev, interface="jax")
 value_and_grad_jax = jax.jit(jax.value_and_grad(qnode_jax))
 
diff --git a/demonstrations_v2/tutorial_optimal_control/demo.py b/demonstrations_v2/tutorial_optimal_control/demo.py
index 635b8dfa90..953cb20074 100644
--- a/demonstrations_v2/tutorial_optimal_control/demo.py
+++ b/demonstrations_v2/tutorial_optimal_control/demo.py
@@ -698,7 +698,7 @@ def profit(params):
 # and zeros elsewhere.
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @qml.qnode(dev, interface="jax")
 def node(params):
diff --git a/demonstrations_v2/tutorial_period_finding/demo.py b/demonstrations_v2/tutorial_period_finding/demo.py
index a8cedd5348..324143274a 100644
--- a/demonstrations_v2/tutorial_period_finding/demo.py
+++ b/demonstrations_v2/tutorial_period_finding/demo.py
@@ -208,8 +208,7 @@ def Oracle(f):
 # reason we define a device with 2 shots. We also add some snapshots to the circuit that we will look at later.
 
 
-dev = qml.device("default.qubit", wires=7)
-
+dev = qml.device("lightning.qubit", wires=7)
 
 @qml.set_shots(2)
 @qml.qnode(dev)
@@ -271,7 +270,7 @@ def circuit():
 # look at the states that were prepared by making use of the snapshots we recorded during the
 # circuit simulation.
 
-dev = qml.device("default.qubit", wires=7)
+dev = qml.device("lightning.qubit", wires=7)
 qnode = qml.set_shots(qml.QNode(circuit, dev), shots = 1)
 intermediate_states = qml.snapshots(circuit)()
 
diff --git a/demonstrations_v2/tutorial_phase_kickback/demo.py b/demonstrations_v2/tutorial_phase_kickback/demo.py
index bf3d0c56c8..8a8529ac83 100644
--- a/demonstrations_v2/tutorial_phase_kickback/demo.py
+++ b/demonstrations_v2/tutorial_phase_kickback/demo.py
@@ -50,7 +50,7 @@
 
 num_wires = 5
 dev = qml.device("default.qubit", wires=num_wires)
-
+"lightning.qubit"
 ######################################################################
 # Building the quantum lock
 # -------------------------
diff --git a/demonstrations_v2/tutorial_post-variational_quantum_neural_networks/demo.py b/demonstrations_v2/tutorial_post-variational_quantum_neural_networks/demo.py
index 77e5e2500b..1b73bb0889 100644
--- a/demonstrations_v2/tutorial_post-variational_quantum_neural_networks/demo.py
+++ b/demonstrations_v2/tutorial_post-variational_quantum_neural_networks/demo.py
@@ -222,7 +222,7 @@ def ansatz(params):
 # ansatz.
 #
 
-dev = qml.device("default.qubit", wires=8)
+dev = qml.device("lightning.qubit", wires=8)
 
 
 @qml.qnode(dev)
@@ -355,7 +355,7 @@ def generate_paulis(identities: int, paulis: int, output: str, qubits: int, loca
     print(str(locality) + "-local: ")
 
     # Define a quantum device with 8 qubits using the default simulator.
-    dev = qml.device("default.qubit", wires=8)
+    dev = qml.device("lightning.qubit", wires=8)
 
     # Define a quantum node (qnode) with the quantum circuit that will be executed on the device.
     @qml.qnode(dev)
@@ -498,7 +498,7 @@ def generate_shifts(thetas: int, order: int):
 #
 
 n_wires = 8
-dev = qml.device("default.qubit", wires=n_wires)
+dev = qml.device("lightning.qubit", wires=n_wires)
 
 @jax.jit
 @qml.qnode(dev, interface="jax")
@@ -612,7 +612,7 @@ def circuit(features, params, n_wires=8):
         print("Locality: " + str(locality) + " Order: " + str(order))
 
         # Define a quantum device with 8 qubits using the default simulator.
-        dev = qml.device("default.qubit", wires=8)
+        dev = qml.device("lightning.qubit", wires=8)
 
         # Generate the parameter shifts required for the given derivative order and transpose them.
         params = deriv_params(16, order).T
diff --git a/demonstrations_v2/tutorial_pulse_programming101/demo.py b/demonstrations_v2/tutorial_pulse_programming101/demo.py
index cd3deac081..cd56a7a62c 100644
--- a/demonstrations_v2/tutorial_pulse_programming101/demo.py
+++ b/demonstrations_v2/tutorial_pulse_programming101/demo.py
@@ -137,7 +137,7 @@ def f2(p, t):
 # is then to compute the expectation value of some objective Hamiltonian ``H_obj`` (here :math:`\sum_i Z_i` as a simple example).
 
 dev = qml.device("default.qubit", range(4))
-
+"lightning.qubit"
 ts = jnp.array([0.0, 3.0])
 H_obj = sum([qml.PauliZ(i) for i in range(4)])
 
@@ -324,7 +324,7 @@ def wrapped(p, t):
 # This will enable use to make use of gradient descent methods that require real-valued loss functions.
 
 dev = qml.device("default.qubit", wires=range(n_wires))
-
+"lightning.qubit"
 def qnode(theta, t=duration):
 
     @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_qaoa_intro/demo.py b/demonstrations_v2/tutorial_qaoa_intro/demo.py
index 8c86f00dae..3fd1a84e68 100644
--- a/demonstrations_v2/tutorial_qaoa_intro/demo.py
+++ b/demonstrations_v2/tutorial_qaoa_intro/demo.py
@@ -91,7 +91,7 @@
 # Hamiltonian:
 
 dev = qml.device("default.qubit", wires=2)
-
+"lightning.qubit"
 t = 1
 n = 2
 
diff --git a/demonstrations_v2/tutorial_qcbm/demo.py b/demonstrations_v2/tutorial_qcbm/demo.py
index 375c2dc519..4542a623dd 100644
--- a/demonstrations_v2/tutorial_qcbm/demo.py
+++ b/demonstrations_v2/tutorial_qcbm/demo.py
@@ -239,7 +239,7 @@ def get_bars_and_stripes(n):
 
 
 n_qubits = size
-dev = qml.device("default.qubit", wires=n_qubits)
+dev = qml.device("lightning.qubit", wires=n_qubits)
 
 n_layers = 6
 wshape = qml.StronglyEntanglingLayers.shape(n_layers=n_layers, n_wires=n_qubits)
@@ -389,7 +389,7 @@ def circuit(weights):
 
 
 for N in [2000, 20000]:
-    dev = qml.device("default.qubit", wires=n_qubits)
+    dev = qml.device("lightning.qubit", wires=n_qubits)
     circ = qml.set_shots(qml.QNode(circuit, device=dev), shots = N)
     preds = circ(weights)
     mask = np.any(np.all(preds[:, None] == data, axis=2), axis=1)  # Check for row-wise equality
@@ -462,7 +462,7 @@ def mixture_gaussian_pdf(x, mus, sigmas):
 # we will create an ansatz and measure probabilities.
 #
 
-dev = qml.device("default.qubit", wires=n_qubits)
+dev = qml.device("lightning.qubit", wires=n_qubits)
 
 n_layers = 4
 wshape = qml.StronglyEntanglingLayers.shape(n_layers=n_layers, n_wires=n_qubits)
diff --git a/demonstrations_v2/tutorial_qft/demo.py b/demonstrations_v2/tutorial_qft/demo.py
index 550a5fd14c..2191b01e81 100644
--- a/demonstrations_v2/tutorial_qft/demo.py
+++ b/demonstrations_v2/tutorial_qft/demo.py
@@ -130,7 +130,7 @@ def prep():
     qml.ControlledSequence(qml.PhaseShift(-2 * np.pi / 10, wires=0), control=range(1, 6))
     qml.PauliX(wires=0)
 
-dev = qml.device("default.qubit")
+dev = qml.device("lightning.qubit")
 @qml.qnode(dev)
 def circuit():
     prep()
diff --git a/demonstrations_v2/tutorial_qft_and_groups/demo.py b/demonstrations_v2/tutorial_qft_and_groups/demo.py
index 939a835451..267c700ea9 100644
--- a/demonstrations_v2/tutorial_qft_and_groups/demo.py
+++ b/demonstrations_v2/tutorial_qft_and_groups/demo.py
@@ -252,7 +252,7 @@ def h_hat(k):
 import pennylane as qml
 
 dev = qml.device("default.qubit", wires=4, shots=None)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def qft(state):
     """Prepare a state \sum_x f(x) |x> and apply the discrete Fourier transform."""
diff --git a/demonstrations_v2/tutorial_qft_arithmetics/demo.py b/demonstrations_v2/tutorial_qft_arithmetics/demo.py
index 4bf57edc8e..2538a6c2cc 100644
--- a/demonstrations_v2/tutorial_qft_arithmetics/demo.py
+++ b/demonstrations_v2/tutorial_qft_arithmetics/demo.py
@@ -103,7 +103,7 @@
 import matplotlib.pyplot as plt
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 @qml.compile
 @qml.qnode(dev)
 def basis_embedding_circuit(m):
@@ -174,7 +174,7 @@ def basis_embedding_circuit(m):
 n_wires = 4
 dev = qml.device("default.qubit", wires=n_wires)
 
-def add_k_fourier(k, wires):
+def add_k_fourier"lightning.qubit"
     for j in range(len(wires)):
         qml.RZ(k * np.pi / (2**j), wires=wires[j])
 
@@ -235,7 +235,7 @@ def sum(m, k):
 
 dev = qml.device("default.qubit", wires=wires_m + wires_k + wires_solution)
 
-n_wires = len(dev.wires) # total number of qubits used
+n_wires = len(dev"lightning.qubit" number of qubits used
 
 def addition(wires_m, wires_k, wires_solution):
     # prepare solution qubits to counting
@@ -302,7 +302,7 @@ def sum2(m, k, wires_m, wires_k, wires_solution):
 
 dev = qml.device("default.qubit", wires=wires_m + wires_k + wires_solution)
 
-n_wires = len(dev.wires)
+n_wires = len(dev"lightning.qubit"
 
 def multiplication(wires_m, wires_k, wires_solution):
     # prepare sol-qubits to counting
@@ -377,7 +377,7 @@ def mul(m, k):
 
 dev = qml.device("default.qubit", wires=wires_m + wires_k + wires_solution)
 
-n_wires = len(dev.wires)
+n_wires = len(dev"lightning.qubit"
 
 @qml.qnode(dev)
 def factorization(n, wires_m, wires_k, wires_solution):
diff --git a/demonstrations_v2/tutorial_qgrnn/demo.py b/demonstrations_v2/tutorial_qgrnn/demo.py
index db0de46c7e..a8224302c4 100644
--- a/demonstrations_v2/tutorial_qgrnn/demo.py
+++ b/demonstrations_v2/tutorial_qgrnn/demo.py
@@ -552,7 +552,7 @@ def cost_function(weight_params, bias_params):
 
 # Defines the new device
 qgrnn_dev = qml.device("default.qubit", wires=2 * qubit_number + 1)
-
+"lightning.qubit"
 # Defines the new QNode
 qgrnn_qnode = qml.QNode(qgrnn, qgrnn_dev)
 
diff --git a/demonstrations_v2/tutorial_qjit_compile_grovers_algorithm_with_catalyst/demo.py b/demonstrations_v2/tutorial_qjit_compile_grovers_algorithm_with_catalyst/demo.py
index fbb1de821e..1ab63983a8 100644
--- a/demonstrations_v2/tutorial_qjit_compile_grovers_algorithm_with_catalyst/demo.py
+++ b/demonstrations_v2/tutorial_qjit_compile_grovers_algorithm_with_catalyst/demo.py
@@ -102,14 +102,14 @@ def grover_circuit(num_qubits):
 
 ######################################################################
 # We'll begin with a circuit defined using the default state-simulator device, ``"default.qubit"``,
-# as our baseline. See the documentation in :func:`~.pennylane.device` for a list of other supported
+# as our baseline. See the documentation in :func:`~.pennylane.device` for a list"lightning.qubit"rted
 # devices. To run our performance benchmarks, we'll increase the number of qubits in our circuit to
 # :math:`n = 12.`
 
 NUM_QUBITS = 12
 
 dev = qml.device("default.qubit", wires=NUM_QUBITS)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit_default_qubit():
@@ -153,7 +153,7 @@ def print_most_probable_states_descending(probs, N):
 # Catalyst is developed natively for `PennyLane's high-performance simulators
 # <https://pennylane.ai/performance/>`__ and, at the time of writing, does not support the
 # ``"default.qubit"`` state-simulator device. Let's first define a new circuit using `Lightning
-# <https://docs.pennylane.ai/projects/lightning>`__, which is a PennyLane plugin that provides more
+# <h"lightning.qubit"nylane.ai/projects/lightning>`__, which is a PennyLane plugin that provides more
 # performant state simulators written in C++. See the :doc:`Catalyst documentation
 # <catalyst:dev/devices>` for the full list of devices supported by Catalyst.
 
@@ -238,7 +238,7 @@ def circuit_lightning():
 # profile:
 #
 # #. Executing the circuit using ``"default.qubit"``.
-# #. Executing the circuit using ``"lightning.qubit"``.
+# #. Executing the circuit using ``"lightning.qubit"t"``.
 # #. Compiling the circuit with Catalyst, to measure the AOT compilation overhead.
 # #. Calls to the QJIT-compiled circuit, to measure the circuit execution time.
 #
diff --git a/demonstrations_v2/tutorial_qnn_module_torch/demo.py b/demonstrations_v2/tutorial_qnn_module_torch/demo.py
index bd7e4fb028..574d54e6e0 100644
--- a/demonstrations_v2/tutorial_qnn_module_torch/demo.py
+++ b/demonstrations_v2/tutorial_qnn_module_torch/demo.py
@@ -80,7 +80,7 @@
 
 n_qubits = 2
 dev = qml.device("default.qubit", wires=n_qubits)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def qnode(inputs, weights):
     qml.AngleEmbedding(inputs, wires=range(n_qubits))
diff --git a/demonstrations_v2/tutorial_qpe/demo.py b/demonstrations_v2/tutorial_qpe/demo.py
index a72acb027d..f2de34ad30 100644
--- a/demonstrations_v2/tutorial_qpe/demo.py
+++ b/demonstrations_v2/tutorial_qpe/demo.py
@@ -221,7 +221,7 @@ def U(wires):
 
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit_qpe(estimation_wires):
     # initialize to state |1>
diff --git a/demonstrations_v2/tutorial_qsvt_hardware/demo.py b/demonstrations_v2/tutorial_qsvt_hardware/demo.py
index 2130f6538e..636e1f6b0d 100644
--- a/demonstrations_v2/tutorial_qsvt_hardware/demo.py
+++ b/demonstrations_v2/tutorial_qsvt_hardware/demo.py
@@ -117,7 +117,7 @@
 
 dev = qml.device("default.qubit")
 
-@qml.qnode(dev)
+@qml.qnode(dev)"lightning.qubit"
 def circuit():
 
     qml.Hadamard(0)
diff --git a/demonstrations_v2/tutorial_quantum_chebyshev_transform/demo.py b/demonstrations_v2/tutorial_quantum_chebyshev_transform/demo.py
index ba6131bd52..8a42b4f4b8 100644
--- a/demonstrations_v2/tutorial_quantum_chebyshev_transform/demo.py
+++ b/demonstrations_v2/tutorial_quantum_chebyshev_transform/demo.py
@@ -248,7 +248,7 @@ def QChT():
 
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(state=0):
diff --git a/demonstrations_v2/tutorial_quantum_circuit_cutting/demo.py b/demonstrations_v2/tutorial_quantum_circuit_cutting/demo.py
index bdcfb59cb2..ca8d46638b 100644
--- a/demonstrations_v2/tutorial_quantum_circuit_cutting/demo.py
+++ b/demonstrations_v2/tutorial_quantum_circuit_cutting/demo.py
@@ -133,7 +133,7 @@
 from pennylane import numpy as np
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(x):
@@ -168,7 +168,7 @@ def circuit(x):
 #
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 # Quantum Circuit with QNode
 
 
@@ -202,7 +202,7 @@ def circuit(x):
 # ``circuit`` function to perform circuit cutting on the quantum circuit.
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 # Quantum Circuit with QNode
 
 
@@ -294,7 +294,7 @@ def circuit(x):
 #
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 
 @partial(qml.cut_circuit, auto_cutter=True)  # auto_cutter enabled
 @qml.qnode(dev)
@@ -559,7 +559,7 @@ def qaoa_template(params):
 #
 
 dev = qml.device("default.qubit", wires=all_wires)
-
+"lightning.qubit"
 
 @partial(qml.cut_circuit_mc, classical_processing_fn=qaoa_cost)
 @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_quantum_dropout/demo.py b/demonstrations_v2/tutorial_quantum_dropout/demo.py
index 4469c56943..2ab116881b 100644
--- a/demonstrations_v2/tutorial_quantum_dropout/demo.py
+++ b/demonstrations_v2/tutorial_quantum_dropout/demo.py
@@ -170,8 +170,7 @@ def var_ansatz(
 
 
 def create_circuit(n_qubits, layers):
-    device = qml.device("default.qubit", wires=n_qubits)
-
+    device = qml.device("lightning.qubit", wires=n_qubits)
     @qml.qnode(device)
     def circuit(x, theta, keep_rot):
         # print(x)
diff --git a/demonstrations_v2/tutorial_quantum_transfer_learning/demo.py b/demonstrations_v2/tutorial_quantum_transfer_learning/demo.py
index 1cf90b6c24..4085f7f759 100644
--- a/demonstrations_v2/tutorial_quantum_transfer_learning/demo.py
+++ b/demonstrations_v2/tutorial_quantum_transfer_learning/demo.py
@@ -168,7 +168,7 @@
 # We initialize a PennyLane device with a ``default.qubit`` backend.
 
 dev = qml.device("default.qubit", wires=n_qubits)
-
+"lightning.qubit"
 ##############################################################################
 # We configure PyTorch to use CUDA only if available. Otherwise the CPU is used.
 
diff --git a/demonstrations_v2/tutorial_quanvolution/demo.py b/demonstrations_v2/tutorial_quanvolution/demo.py
index 7ada3a800c..a2d1f3ee88 100644
--- a/demonstrations_v2/tutorial_quanvolution/demo.py
+++ b/demonstrations_v2/tutorial_quanvolution/demo.py
@@ -147,7 +147,7 @@
 
 
 dev = qml.device("default.qubit", wires=4)
-# Random circuit parameters
+# Random circuit "lightning.qubit"
 rand_params = np.random.uniform(high=2 * np.pi, size=(n_layers, 4))
 
 @qml.qnode(dev)
diff --git a/demonstrations_v2/tutorial_qubit_tapering/demo.py b/demonstrations_v2/tutorial_qubit_tapering/demo.py
index 5f338e68f3..5cd6cb978b 100644
--- a/demonstrations_v2/tutorial_qubit_tapering/demo.py
+++ b/demonstrations_v2/tutorial_qubit_tapering/demo.py
@@ -215,7 +215,7 @@
 # Hartree-Fock energies for each Hamiltonian.
 
 dev = qml.device("default.qubit", wires=H.wires)
-@qml.qnode(dev, interface="jax")
+@qml.qnode(dev, i"lightning.qubit"
 def circuit():
     qml.BasisState(jnp.array([1, 1, 0, 0]), wires=H.wires)
     return qml.state()
diff --git a/demonstrations_v2/tutorial_qubitization/demo.py b/demonstrations_v2/tutorial_qubitization/demo.py
index f4382e3460..73005c37c8 100644
--- a/demonstrations_v2/tutorial_qubitization/demo.py
+++ b/demonstrations_v2/tutorial_qubitization/demo.py
@@ -111,7 +111,7 @@
 estimation_wires = [4, 5, 6, 7, 8, 9]
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit():
diff --git a/demonstrations_v2/tutorial_qutrits_bernstein_vazirani/demo.py b/demonstrations_v2/tutorial_qutrits_bernstein_vazirani/demo.py
index be3dfde8c2..8db13b3514 100644
--- a/demonstrations_v2/tutorial_qutrits_bernstein_vazirani/demo.py
+++ b/demonstrations_v2/tutorial_qutrits_bernstein_vazirani/demo.py
@@ -129,7 +129,7 @@
 import pennylane as qml
 
 dev = qml.device("default.qubit", wires = 4)
-
+"lightning.qubit"
 def Uf():
     # The oracle in charge of encoding a hidden "a" value.
     qml.CNOT(wires=[1, 3])
diff --git a/demonstrations_v2/tutorial_resourcefulness/demo.py b/demonstrations_v2/tutorial_resourcefulness/demo.py
index d169f10232..74262dfefc 100644
--- a/demonstrations_v2/tutorial_resourcefulness/demo.py
+++ b/demonstrations_v2/tutorial_resourcefulness/demo.py
@@ -364,7 +364,7 @@ def g(x):
 
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def product_state(n_qubits):
     for i in range(n_qubits):
diff --git a/demonstrations_v2/tutorial_rl_pulse/demo.py b/demonstrations_v2/tutorial_rl_pulse/demo.py
index 0b40f614e2..ec44dc4c85 100644
--- a/demonstrations_v2/tutorial_rl_pulse/demo.py
+++ b/demonstrations_v2/tutorial_rl_pulse/demo.py
@@ -218,7 +218,7 @@
 from functools import partial
 
 device = qml.device("default.qubit", wires=1)
-
+"lightning.qubit"
 
 @partial(jax.jit, static_argnames="H")
 @partial(jax.vmap, in_axes=(0, None, 0, None))
diff --git a/demonstrations_v2/tutorial_rosalin/demo.py b/demonstrations_v2/tutorial_rosalin/demo.py
index b179d3eebc..be981e9613 100644
--- a/demonstrations_v2/tutorial_rosalin/demo.py
+++ b/demonstrations_v2/tutorial_rosalin/demo.py
@@ -135,11 +135,9 @@
 num_wires = 2
 
 # create a device that estimates expectation values using a finite number of shots
-non_analytic_dev = qml.device("default.qubit", wires=num_wires, seed=432423)
-
+non_analytic_dev = qml.device("lightning.qubit", wires=num_wires, seed=432423)
 # create a device that calculates exact expectation values
-analytic_dev = qml.device("default.qubit", wires=num_wires)
-
+analytic_dev = qml.device("lightning.qubit", wires=num_wires)
 ##############################################################################
 # Now, let's set the total number of shots, and determine the probability
 # for sampling each Hamiltonian term.
@@ -438,8 +436,7 @@ def estimate_hamiltonian(self, params, shots):
         set to 'sample' mode.
         """
         # note that convergence depends on seed for random number generation
-        rosalin_device = qml.device("default.qubit", wires=num_wires, seed=93754352)
-
+        rosalin_device = qml.device("lightning.qubit", wires=num_wires, seed=93754352)
         # determine the shot probability per term
         prob_shots = np.abs(coeffs) / np.sum(np.abs(coeffs))
 
diff --git a/demonstrations_v2/tutorial_shadow_hamiltonian_simulation/demo.py b/demonstrations_v2/tutorial_shadow_hamiltonian_simulation/demo.py
index e03d4ab9dc..175427a0b8 100644
--- a/demonstrations_v2/tutorial_shadow_hamiltonian_simulation/demo.py
+++ b/demonstrations_v2/tutorial_shadow_hamiltonian_simulation/demo.py
@@ -139,7 +139,7 @@
 from pennylane import X, Y, Z, I
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 S = [X(0), Y(0), Z(0), I(0)]
 H = X(0) + Y(0)
 
diff --git a/demonstrations_v2/tutorial_stabilizer_codes/demo.py b/demonstrations_v2/tutorial_stabilizer_codes/demo.py
index 2a95f47430..266b1da85f 100644
--- a/demonstrations_v2/tutorial_stabilizer_codes/demo.py
+++ b/demonstrations_v2/tutorial_stabilizer_codes/demo.py
@@ -83,12 +83,12 @@ def encoded_state(alpha, beta):
 
 
 encode_qnode = qml.QNode(encoded_state, qml.device("default.qubit"))
-
+"lightning.qubit"
 alpha = 1 / np.sqrt(2)
 beta = 1 / np.sqrt(2)
 
 encode_qnode = qml.QNode(encoded_state, qml.device("default.qubit"))
-
+"lightning.qubit"
 print("|000> component: ", encode_qnode(alpha, beta)[0])
 print("|111> component: ", encode_qnode(alpha, beta)[7])
 
@@ -146,7 +146,7 @@ def error_detection():
 
 @qml.set_shots(1)
 @qml.qnode(qml.device("default.qubit", wires=5))  # A single sample flags error
-def syndrome_measurement(error_wire):
+def syndrome_measureme"lightning.qubit"
     encode(alpha, beta)
 
     qml.PauliX(wires=error_wire)  # Unwanted Pauli Operator
@@ -191,7 +191,7 @@ def syndrome_measurement(error_wire):
 
 
 @qml.qnode(qml.device("default.qubit", wires=5))
-def error_correction(error_wire):
+def error_correction(e"lightning.qubit"
     encode(alpha, beta)
 
     qml.PauliX(wires=error_wire)
@@ -221,7 +221,7 @@ def error_correction(error_wire):
 # as follows.
 
 dev = qml.device("default.qubit", wires=5)
-error_correction_qnode = qml.QNode(error_correction, dev)
+error_correction_"lightning.qubit"de(error_correction, dev)
 encoded_state = qml.math.dm_from_state_vector(encode_qnode(alpha, beta))
 
 # Compute fidelity of final corrected state with initial encoded state
@@ -628,7 +628,7 @@ def five_qubit_error_detection():
 #
 
 dev = qml.device("default.qubit", wires=9)
-
+"lightning.qubit"
 
 @qml.set_shots(1)
 @qml.qnode(dev)
@@ -698,7 +698,7 @@ def syndrome_booleans(syndrome, measurements):
 # Combining all these pieces, we can write the full error correcting code.
 #
 dev = qml.device("default.qubit", wires=9)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def five_qubit_code(alpha, beta, error_op, error_wire):
@@ -729,7 +729,7 @@ def five_qubit_code(alpha, beta, error_op, error_wire):
 
 
 @qml.qnode(qml.device("default.qubit", wires=5))
-def five_qubit_encoded_state(alpha, beta):
+def five_qubit_encoded"lightning.qubit"eta):
     five_qubit_encode(alpha, beta)
     return qml.state()
 
diff --git a/demonstrations_v2/tutorial_state_preparation/demo.py b/demonstrations_v2/tutorial_state_preparation/demo.py
index f91faefdb0..3e46708d53 100644
--- a/demonstrations_v2/tutorial_state_preparation/demo.py
+++ b/demonstrations_v2/tutorial_state_preparation/demo.py
@@ -113,7 +113,7 @@ def layer(params, j):
 # any other supported device.
 
 dev = qml.device("default.qubit", wires=3)
-
+"lightning.qubit"
 ##############################################################################
 # When defining the QNode, we introduce as input a Hermitian operator
 # :math:`A` that specifies the expectation value being evaluated. This
diff --git a/demonstrations_v2/tutorial_teleportation/demo.py b/demonstrations_v2/tutorial_teleportation/demo.py
index 37ed6f2605..1b6cdd104b 100644
--- a/demonstrations_v2/tutorial_teleportation/demo.py
+++ b/demonstrations_v2/tutorial_teleportation/demo.py
@@ -317,7 +317,7 @@ def teleport(state):
 # runs the device pre-processing before drawing the circuit.
 
 dev = qml.device("default.qubit", wires=["S", "A", "B"])
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def teleport(state):
diff --git a/demonstrations_v2/tutorial_tn_circuits/demo.py b/demonstrations_v2/tutorial_tn_circuits/demo.py
index 77bad8c5f1..d36691661f 100644
--- a/demonstrations_v2/tutorial_tn_circuits/demo.py
+++ b/demonstrations_v2/tutorial_tn_circuits/demo.py
@@ -132,7 +132,7 @@ def block(weights, wires):
 # operator on the bottom qubit.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(template_weights):
@@ -167,7 +167,7 @@ def deep_block(weights, wires):
 # ``n_params_block = 3`` to suit the new block.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(template_weights):
@@ -216,7 +216,7 @@ def wide_block(weights, wires):
 # dimension than the previous ones and would correspond to an MPS with a bond dimension of four.
 
 dev = qml.device("default.qubit", wires=8)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(template_weights):
@@ -247,7 +247,7 @@ def block(weights, wires):
 
 
 dev = qml.device("default.qubit", wires=8)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(template_weights):
@@ -324,7 +324,7 @@ def block(weights, wires):
 # encoding appears in the initial :class:`~pennylane.PauliX` gates.
 
 dev = qml.device("default.qubit", wires=4)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def circuit(image, template_weights):
diff --git a/demonstrations_v2/tutorial_trapped_ions/demo.py b/demonstrations_v2/tutorial_trapped_ions/demo.py
index f6eff7e30d..7e45f8715e 100644
--- a/demonstrations_v2/tutorial_trapped_ions/demo.py
+++ b/demonstrations_v2/tutorial_trapped_ions/demo.py
@@ -420,7 +420,7 @@ def evolution(phi, t):
 # with different phases and durations that yield the Hadamard gate:
 
 dev = qml.device("default.qubit", wires=1)
-
+"lightning.qubit"
 
 @qml.qnode(dev)
 def ion_hadamard(state):
@@ -810,7 +810,7 @@ def Molmer_Sorensen(t):
 # by building the circuit in PennyLane:
 
 dev2 = qml.device("default.qubit",wires=2)
-
+"lightning.qubit"
 @qml.qnode(dev2)
 def ion_cnot(basis_state):
     
diff --git a/demonstrations_v2/tutorial_univariate_qvr/demo.py b/demonstrations_v2/tutorial_univariate_qvr/demo.py
index cb4a682061..24fe7014c3 100644
--- a/demonstrations_v2/tutorial_univariate_qvr/demo.py
+++ b/demonstrations_v2/tutorial_univariate_qvr/demo.py
@@ -471,7 +471,7 @@ def D(gamma: torch.Tensor, n_qubits: int, k: int = None, get_probs: bool = False
 
 n_qubits = 1
 dev = qml.device("default.qubit", wires=n_qubits)
-D_one_qubit = qml.qnode(dev)(D)
+D_one_qubit = qml"lightning.qubit"
 _ = qml.draw_mpl(D_one_qubit, decimals=2)(torch.tensor([1, 0]), 1, 1, True)
 
 ######################################################################
diff --git a/demonstrations_v2/tutorial_variational_classifier/demo.py b/demonstrations_v2/tutorial_variational_classifier/demo.py
index 4e1198574f..5da4af750e 100644
--- a/demonstrations_v2/tutorial_variational_classifier/demo.py
+++ b/demonstrations_v2/tutorial_variational_classifier/demo.py
@@ -64,7 +64,7 @@
 # We then create a quantum device that will run our circuits.
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 ##############################################################################
 # Variational classifiers usually define a “layer” or “block”, which is an
 # elementary circuit architecture that gets repeated to build the
diff --git a/demonstrations_v2/tutorial_vqe_qng/demo.py b/demonstrations_v2/tutorial_vqe_qng/demo.py
index d235c5fbc9..210b551666 100644
--- a/demonstrations_v2/tutorial_vqe_qng/demo.py
+++ b/demonstrations_v2/tutorial_vqe_qng/demo.py
@@ -39,7 +39,7 @@
 #
 # We define the device:
 
-dev = qml.device("default.qubit", wires=1)
+dev = qml.device("lightning.qubit", wires=1)
 
 
 ##############################################################################
@@ -272,7 +272,7 @@ def cost_fn(params):
 # but expand out the arbitrary single-qubit rotations to elementary
 # gates (RZ-RY-RZ).
 
-dev = qml.device("default.qubit", wires=qubits)
+dev = qml.device("lightning.qubit", wires=qubits)
 hf_state = np.array([1, 1, 0, 0], requires_grad=False)
 
 def ansatz(params, wires=[0, 1, 2, 3]):
diff --git a/demonstrations_v2/tutorial_vqe_vqd/demo.py b/demonstrations_v2/tutorial_vqe_vqd/demo.py
index a899af0c90..983fce46ab 100644
--- a/demonstrations_v2/tutorial_vqe_vqd/demo.py
+++ b/demonstrations_v2/tutorial_vqe_vqd/demo.py
@@ -78,7 +78,7 @@ def generate_ground_state(wires):
 #
 
 dev = qml.device("default.qubit")
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     generate_ground_state(range(n_qubits))
diff --git a/demonstrations_v2/tutorial_zx_calculus/demo.py b/demonstrations_v2/tutorial_zx_calculus/demo.py
index 6f04aa2b7b..e813174814 100644
--- a/demonstrations_v2/tutorial_zx_calculus/demo.py
+++ b/demonstrations_v2/tutorial_zx_calculus/demo.py
@@ -517,7 +517,7 @@
 import pyzx
 
 dev = qml.device("default.qubit", wires=2)
-
+"lightning.qubit"
 
 @qml.transforms.to_zx
 @qml.qnode(device=dev)
@@ -630,7 +630,7 @@ def circuit():
 
 
 dev = qml.device("default.qubit", wires=5)
-
+"lightning.qubit"
 
 @qml.transforms.to_zx
 @qml.qnode(device=dev)
diff --git a/documentation/reference_demo/demo.py b/documentation/reference_demo/demo.py
index 80defeef0f..b3050f2703 100644
--- a/documentation/reference_demo/demo.py
+++ b/documentation/reference_demo/demo.py
@@ -657,7 +657,7 @@
 import pennylane as qml
 
 dev = qml.device("default.qubit", wires=2)
-
+"lightning.qubit"
 @qml.qnode(dev)
 def circuit():
     qml.RX(0.5, wires=0)