diff --git a/mods/circuitcore.js b/mods/circuitcore.js
index d5edbfdc..c214cc5c 100644
--- a/mods/circuitcore.js
+++ b/mods/circuitcore.js
@@ -1,19 +1,86 @@
 // CircuitCore: adds circuits to sandboxels, logicgates.js is required
 
-/*if (!enabledMods.includes("mods/betterSettings.js")) { enabledMods.unshift("mods/betterSettings.js"); localStorage.setItem("enabledMods", JSON.stringify(enabledMods)); window.location.reload() };
+if (!enabledMods.includes("mods/betterSettings.js")) { enabledMods.unshift("mods/betterSettings.js"); localStorage.setItem("enabledMods", JSON.stringify(enabledMods)); window.location.reload() };
+if (!enabledMods.includes("mods/logicgates.js")) { enabledMods.unshift("mods/logicgates.js"); localStorage.setItem("enabledMods", JSON.stringify(enabledMods)); window.location.reload() };
+var lightmapEnabled = enabledMods.includes("mods/lightmap.js") || enabledMods.includes("mods/fast_lightmap.js");
 
 var cc_settingsTab = new SettingsTab("CircuitCore");
-var cc_setting1 = new Setting("Default Memory Fill; 0=empty,1=random,2=fill custom,3=custom data", "mem_fill", settingType.NUMBER, false, "The default method used to initialize ROM/RAM memory devices");
-var cc_setting2 = new Setting("Example Setting 2", "element", settingType.TEXT, false, "2");
-cc_settingsTab.registerSettings("Default Memory Fill", cc_setting1);
-cc_settingsTab.registerSettings("Setting 2", cc_setting2);
-settingsManager.registerTab(cc_settingsTab);*/
+var cc_setting1 = new Setting("If true then circuits will emit heat", "mem_fill", settingType.BOOLEAN, false, defaultValue=true);
+//var cc_setting2 = new Setting("Example Setting 2", "element", settingType.TEXT, false, "2");
+cc_settingsTab.registerSettings("OverHeating", cc_setting1);
+//cc_settingsTab.registerSettings("Setting 2", cc_setting2);
+settingsManager.registerTab(cc_settingsTab);
 
 var dataVisualizationPalette16 = [
 	"#000000", "#ff0000", "#ff7700", "#ffff00", "#00ff00", "#00ffff", "#0000ff", "#ff00ff",
 	"#777777", "#770000", "#773300", "#777700", "#007700", "#007777", "#000077", "#770077",
 ];
 
+function hueLerp(value) {
+    // Clamp the value between -50 and 400
+    if (value < -50) value = -50;
+    if (value > 400) value = 400;
+
+    let r, g, b;
+
+    if (value <= 300) {
+        // Interpolate between blue and red
+        let t = (value + 50) / 350; // Normalize value from -50 to 300 to a 0-1 range
+        r = Math.round(255 * t);
+        g = 0;
+        b = Math.round(255 * (1 - t));
+    } else {
+        // Interpolate between red and white
+        let t = (value - 300) / 100; // Normalize value from 300 to 400 to a 0-1 range
+        r = 255;
+        g = Math.round(255 * t);
+        b = Math.round(255 * t);
+    }
+
+    // Convert RGB values to a hex string
+    return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase();
+}
+
+function cc_rgbToArray(colorString) {
+	if (typeof colorString !== 'string') {
+		console.error('Invalid colorString:', colorString);
+		return null;
+	}
+
+	if (colorString.startsWith('rgb')) {
+		return colorString.slice(4, -1).split(',').map(val => parseInt(val.trim()));
+	} else if (colorString.startsWith('#')) {
+		let hex = colorString.slice(1);
+
+		// Handle shorthand hex (e.g., #03F)
+		if (hex.length === 3) {
+			hex = hex.split('').map(char => char + char).join('');
+		}
+
+		if (hex.length !== 6) {
+			console.error('Invalid hex color:', colorString);
+			return null;
+		}
+
+		const r = parseInt(hex.slice(0, 2), 16);
+		const g = parseInt(hex.slice(2, 4), 16);
+		const b = parseInt(hex.slice(4, 6), 16);
+
+		return [r, g, b];
+	} else {
+		console.error('Invalid color format:', colorString);
+		return null;
+	}
+}
+
+function cc_arrayToRgbString(rgbArray) {
+    return `rgb(${rgbArray.join(', ')})`;
+}
+
+function cc_scaleList(numbers, scale) {
+	return numbers.map(number => number * scale);
+}
+
 function binaryArrayToNumber(binaryArray) {
 	return binaryArray.reduce((acc, bit, index) => acc + bit * Math.pow(2, (binaryArray.length - 1) - index), 0);
 }
@@ -152,7 +219,7 @@ function setPin(pixel, pins, index, value, rotation=pixel.circuitRotation) {
 // Circuits
 elements.four_bit_enabler_circuit = {
 	centered: true,
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
 			[-3, -2, true],  // D0
@@ -209,7 +276,7 @@ elements.four_bit_enabler_circuit = {
 
 elements.randomizer = {
 	color: "#FFCCFF",
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		for (var i = 0; i < adjacentCoords.length; i++) {
 			var coord = adjacentCoords[i];
 			var x = pixel.x + coord[0];
@@ -230,7 +297,7 @@ elements.randomizer = {
 }
 
 elements.four_bit_randomizer_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Clock input
 			[0, -2, true],   // Clock
@@ -278,9 +345,51 @@ elements.four_bit_randomizer_circuit = {
 	}
 };
 
+var tempVar = 0;
+elements.temperature_sensor = {
+    behavior: behaviors.WALL,
+	onSelect: function() {
+        var answertemp = Number(prompt("Set your target temperature:",(tempVar||undefined)));
+        if (!answertemp) { return }
+		tempVar = answertemp;
+    },
+    hoverStat: function(pixel) {
+		return `TargetTmp: {pixel.targetTemp}`;
+	},
+	cc_stableTick: function(pixel) {
+		if (pixel.start === pixelTicks){
+			pixel.targetTemp = tempVar;
+		}
+
+		pixel.color = hueLerp(pixel.targetTemp);
+
+		pixel.active = pixel.temp >= pixel.targetTemp;
+		var neighbors = getNeighbors(pixel);
+		for (var i = 0;i < neighbors.length;i++) {
+			var neighbor = neighbors[i];
+
+			// Check if it's a wire
+			if (elements[neighbor.element].conduct > 0 && pixel.active) {
+				neighbor.charge = 1;
+			}
+
+			// Check if it's a logic wire (logicgates.js)
+			if (neighbor.lstate != undefined) {
+				if (pixel.active) {
+					neighbor.lstate = 2;
+					neighbor.color = pixelColorPick(neighbor, "#ffe49c");
+				} else {
+					neighbor.lstate = -2;
+					neighbor.color = pixelColorPick(neighbor, "#3d4d2c");
+				}
+			}
+		}
+	}
+}
+
 /*elements.ROM_circuit = {
 	previewSize: false,
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var romWidth = 16;
 		var romHeight = 16;
 
@@ -358,16 +467,17 @@ function general_encoder(inputBits) {
 
 		// Define input pins
 		for (var i = 0; i < inputBits; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) + 1 + 2 * i, outputBits + 1, true]);
+			pins.push([Math.floor(circuitWidth / 2) - 1 - (2 * i), outputBits + 1, true]);
 		}
 
 		// Define output pins
 		for (var i = 0; i < outputBits; i++) {
-			pins.push([Math.floor(circuitWidth / 2) + 1, -outputBits + 1 + 2 * i, false]); // Right outputs
+			pins.push([Math.floor(circuitWidth / 2) + 1, outputBits - 1 - (2 * i), false]); // Right outputs
 		}
 
+		// Mirrored outputs
 		for (var i = 0; i < outputBits; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) - 1, -outputBits + 1 + 2 * i, false]); // Left outputs
+			pins.push([-Math.floor(circuitWidth / 2) - 1, outputBits - 1 - (2 * i), false]); // Left outputs
 		}
 
 		initializeCircuit(pixel, pins, circuitWidth, circuitHeight);
@@ -392,22 +502,22 @@ function general_encoder(inputBits) {
 
 // Define a 2-to-1 encoder using the general_encoder function
 elements.two_to_one_encoder_circuit = {
-	tick: general_encoder(2)
+	cc_stableTick: general_encoder(2)
 };
 
 // Define a 4-to-2 encoder using the general_encoder function
 elements.four_to_two_encoder_circuit = {
-	tick: general_encoder(4)
+	cc_stableTick: general_encoder(4)
 };
 
 // Define an 8-to-3 encoder using the general_encoder function
 elements.eight_to_three_encoder_circuit = {
-	tick: general_encoder(8)
+	cc_stableTick: general_encoder(8)
 };
 
 // Define a 16-to-4 encoder using the general_encoder function
 elements.sixteen_to_four_encoder_circuit = {
-	tick: general_encoder(16)
+	cc_stableTick: general_encoder(16)
 };
 
 function general_demultiplexer(selectorBits) {
@@ -427,7 +537,7 @@ function general_demultiplexer(selectorBits) {
 
 		// Define output pins
 		for (var i = 0; i < outputCount; i++) {
-			pins.push([Math.floor(circuitWidth / 2) + 1, -Math.floor(circuitHeight / 2) + 1 + 2 * i, false]);
+			pins.push([Math.floor(circuitWidth / 2) + 1, Math.floor(circuitHeight / 2) - 1 - (2 * i), false]);
 		}
 
 		initializeCircuit(pixel, pins, circuitWidth, circuitHeight);
@@ -450,22 +560,22 @@ function general_demultiplexer(selectorBits) {
 
 // Define a 1-to-2 demultiplexer using the general_demultiplexer function
 elements.one_to_two_demultiplexer_circuit = {
-	tick: general_demultiplexer(1)
+	cc_stableTick: general_demultiplexer(1)
 };
 
 // Define a 1-to-4 demultiplexer using the general_demultiplexer function
 elements.one_to_four_demultiplexer_circuit = {
-	tick: general_demultiplexer(2)
+	cc_stableTick: general_demultiplexer(2)
 };
 
 // Define a 1-to-8 demultiplexer using the general_demultiplexer function
 elements.one_to_eight_demultiplexer_circuit = {
-	tick: general_demultiplexer(3)
+	cc_stableTick: general_demultiplexer(3)
 };
 
 // Define a 1-to-16 demultiplexer using the general_demultiplexer function
 elements.one_to_sixteen_demultiplexer_circuit = {
-	tick: general_demultiplexer(4)
+	cc_stableTick: general_demultiplexer(4)
 };
 
 function general_decoder(inputBits) {
@@ -477,16 +587,16 @@ function general_decoder(inputBits) {
 
 		// Define input pins
 		for (var i = 0; i < inputBits; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) + 1 + 2 * i, outputCount + 1, true]);
+			pins.push([Math.floor(circuitWidth / 2) - 1 - (2 * i), outputCount + 1, true]);
 		}
 
 		// Define output pins
 		for (var i = 0; i < outputCount; i++) {
-			pins.push([Math.floor(circuitWidth / 2) + 1, -outputCount + 1 + 2 * i, false]); // Right outputs
+			pins.push([Math.floor(circuitWidth / 2) + 1, outputCount - 1 - (2 * i), false]); // Right outputs
 		}
 
 		for (var i = 0; i < outputCount; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) - 1, -outputCount + 1 + 2 * i, false]); // Left outputs
+			pins.push([-Math.floor(circuitWidth / 2) - 1, outputCount - 1 - (2 * i), false]); // Left outputs
 		}
 
 		initializeCircuit(pixel, pins, circuitWidth, circuitHeight);
@@ -509,19 +619,19 @@ function general_decoder(inputBits) {
 }
 
 elements.one_to_two_decoder_circuit = {
-	tick: general_decoder(1)
+	cc_stableTick: general_decoder(1)
 };
 
 elements.two_to_four_decoder_circuit = {
-	tick: general_decoder(2)
+	cc_stableTick: general_decoder(2)
 };
 
 elements.three_to_eight_decoder_circuit = {
-	tick: general_decoder(3)
+	cc_stableTick: general_decoder(3)
 };
 
 elements.four_to_sixteen_decoder_circuit = {
-	tick: general_decoder(4)
+	cc_stableTick: general_decoder(4)
 };
 
 function general_multiplexer(inputLines) {
@@ -533,12 +643,12 @@ function general_multiplexer(inputLines) {
 
 		// Define selector pins
 		for (var i = 0; i < selectorBits; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) + 1 + 2 * i, inputLines + 1, true]);
+			pins.push([Math.floor(circuitWidth / 2) - 1 - (2 * i), inputLines + 1, true]);
 		}
 
 		// Define input data pins
 		for (var i = 0; i < inputLines; i++) {
-			pins.push([-Math.floor(circuitWidth / 2) - 1, -inputLines + 1 + 2 * i, true]);
+			pins.push([-Math.floor(circuitWidth / 2) - 1, inputLines - 1 - (2 * i), true]);
 		}
 
 		// Define output pin
@@ -560,32 +670,32 @@ function general_multiplexer(inputLines) {
 
 // Define a 2-input multiplexer using the general_multiplexer function
 elements.two_to_one_multiplexer_circuit = {
-	tick: general_multiplexer(2)
+	cc_stableTick: general_multiplexer(2)
 };
 
 // Define a 4-input multiplexer using the general_multiplexer function
 elements.four_to_one_multiplexer_circuit = {
-	tick: general_multiplexer(4)
+	cc_stableTick: general_multiplexer(4)
 };
 
 // Define an 8-input multiplexer using the general_multiplexer function
 elements.eight_to_one_multiplexer_circuit = {
-	tick: general_multiplexer(8)
+	cc_stableTick: general_multiplexer(8)
 };
 
 // Define an 8-input multiplexer using the general_multiplexer function
 elements.sixteen_to_one_multiplexer_circuit = {
-	tick: general_multiplexer(16)
+	cc_stableTick: general_multiplexer(16)
 };
 
 elements.four_bit_PISO_shift_register_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
-			[-3, -3, true],  // D0
-			[-1, -3, true],  // D1
-			[1, -3, true],   // D2
 			[3, -3, true],   // D3
+			[1, -3, true],   // D2
+			[-1, -3, true],  // D1
+			[-3, -3, true],  // D0
 
 			// Control input (Load/Shift Enable)
 			[-5, -1, true],  // Load/Shift Enable
@@ -656,7 +766,7 @@ elements.four_bit_PISO_shift_register_circuit = {
 };
 
 elements.four_bit_SIPO_shift_register_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Serial input (Data In)
 			[-2, -3, true],  // Data In
@@ -665,10 +775,10 @@ elements.four_bit_SIPO_shift_register_circuit = {
 			[-2, -1, true],   // Clock
 
 			// Parallel outputs (Q0-Q3)
-			[2, -3, false],  // Q0
-			[2, -1, false],  // Q1
+			[2, 3, false],	// Q3
 			[2, 1, false],   // Q2
-			[2, 3, false]	// Q3
+			[2, -1, false],  // Q1
+			[2, -3, false]  // Q0
 		];
 
 		initializeCircuit(pixel, pins, 3, 9);
@@ -699,7 +809,7 @@ elements.four_bit_SIPO_shift_register_circuit = {
 };
 
 elements.four_bit_program_counter_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
 			[-3, -3, true],  // D0
@@ -771,7 +881,7 @@ elements.four_bit_program_counter_circuit = {
 };
 
 elements.four_bit_register_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
 			[-3, -3, true],  // D0
@@ -831,7 +941,7 @@ elements.four_bit_register_circuit = {
 };
 
 elements.SR_latch_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			[0, -2, true], // Input: Set
 			[0, 2, true],  // Input: Reset
@@ -849,7 +959,7 @@ elements.SR_latch_circuit = {
 };
 
 elements.T_flip_flop_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			[0, -2, true], // Input: Toggle (T)
 			[2, 0, false], // Output (Q)
@@ -880,7 +990,7 @@ elements.T_flip_flop_circuit = {
 };
 
 elements.D_latch_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			[0, -2, true], // Input: Data
 			[2, 0, true],  // Input: Enable
@@ -902,7 +1012,7 @@ elements.D_latch_circuit = {
 };
 
 elements.D_flip_flop_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			[0, -2, true], // Input: Data
 			[2, 0, true],  // Input: Enable
@@ -941,7 +1051,7 @@ elements.D_flip_flop_circuit = {
 };
 
 elements.four_bit_D_latch_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
 			[-3, -2, true],  // D0
@@ -990,7 +1100,7 @@ elements.four_bit_D_latch_circuit = {
 };
 
 elements.four_bit_D_flip_flop_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
 			[-3, -2, true],  // D0
@@ -1047,22 +1157,22 @@ elements.four_bit_D_flip_flop_circuit = {
 };
 
 elements.four_bit_incrementer_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// 4-bit number inputs (N0-N3)
-			[-3, -2, true],  // N0
-			[-1, -2, true],  // N1
-			[1, -2, true],   // N2
 			[3, -2, true],   // N3
+			[1, -2, true],   // N2
+			[-1, -2, true],  // N1
+			[-3, -2, true],  // N0
 
 			// Increment control input (INC)
 			[-5, 0, true],   // Increment (INC)
 
 			// Outputs (Q0-Q3)
-			[-3, 2, false],  // Q0
-			[-1, 2, false],  // Q1
-			[1, 2, false],   // Q2
 			[3, 2, false],   // Q3
+			[1, 2, false],   // Q2
+			[-1, 2, false],  // Q1
+			[-3, 2, false],  // Q0
 
 			// Carry out
 			[5, 0, false]	// Carry out (COUT)
@@ -1104,28 +1214,28 @@ elements.four_bit_incrementer_circuit = {
 };
 
 elements.four_bit_adder_circuit = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// First 4-bit number (A)
-			[-7, -2, true],  // A0
-			[-5, -2, true],  // A1
-			[-3, -2, true],  // A2
 			[-1, -2, true],  // A3
+			[-3, -2, true],  // A2
+			[-5, -2, true],  // A1
+			[-7, -2, true],  // A0
 
 			// Second 4-bit number (B)
-			[1, -2, true],   // B0
-			[3, -2, true],   // B1
-			[5, -2, true],   // B2
 			[7, -2, true],   // B3
+			[5, -2, true],   // B2
+			[3, -2, true],   // B1
+			[1, -2, true],   // B0
 
 			// Carry-in (C_in)
 			[9, 0, true],   // Carry-in (C_in)
 
 			// Output sum (S)
-			[-7, 2, false],  // S0
-			[-5, 2, false],  // S1
-			[-3, 2, false],  // S2
 			[-1, 2, false],  // S3
+			[-3, 2, false],  // S2
+			[-5, 2, false],  // S1
+			[-7, 2, false],  // S0
 			[1, 2, false],   // Carry Out (C4)
 		];
 
@@ -1190,27 +1300,68 @@ function general_clock(speed, s2) {
 
 elements.slow_clock = {
 	color: "#BB66BB",
-	tick: general_clock(64, 32),
+	cc_stableTick: general_clock(64, 32),
 }
 
 elements.medium_clock = {
 	color: "#DD88DD",
-	tick: general_clock(32, 16),
+	cc_stableTick: general_clock(32, 16),
 }
 
 elements.fast_clock = {
 	color: "#FFAAFF",
-	tick: general_clock(16, 8),
+	cc_stableTick: general_clock(16, 8),
 }
 
 elements.very_fast_clock = {
 	color: "#FFCCFF",
-	tick: general_clock(8, 4),
+	cc_stableTick: general_clock(8, 4),
 }
 
-elements.fast_clock = {
-	color: "#FFAAFF",
-	tick: general_clock(16, 8),
+elements.custom_RGB_led = {
+	cc_stableTick: function(pixel) {
+		var pins = [
+			// RGB values
+			[-2, -1, true],  // R0
+			[-2, 1, true],  // R1
+			[1, -2, true],  // G0
+			[-1, -2, true],  // G1
+			[2, -1, true],   // B0
+			[2, 1, true],   // B1
+		];
+
+		initializeCircuit(pixel, pins, 3, 3);
+
+		// Read inputs
+		var l = [
+			checkPin(pixel, pins, 0),
+			checkPin(pixel, pins, 1),
+			checkPin(pixel, pins, 2),
+			checkPin(pixel, pins, 3),
+			checkPin(pixel, pins, 4),
+			checkPin(pixel, pins, 5)
+		];
+
+		var color = { color: cc_scaleList([(l[0] * 2) + l[1], (l[2] * 2) + l[3], (l[4] * 2) + l[5]], (255 / 3) * 10) };
+
+		if (lightmapEnabled && color.color[0] && color.color[1], color.color[2]) {
+			lightmap[Math.floor(pixel.y / lightmapScale)][Math.floor(pixel.x / lightmapScale)] = color;
+		}
+		var scaledColor = cc_scaleList(color.color, 0.1);
+
+//		pixelMap[pixel.x][pixel.y].color = scaledColor;
+		for (let dx = -1; dx <= 1; dx++) {
+			for (let dy = -1; dy <= 1; dy++) {
+				var nx = pixel.x + dx;
+				var ny = pixel.y + dy;
+
+				if (pixelMap[nx] && pixelMap[nx][ny]) {
+					var n = ((2 - (Math.abs(dx) + Math.abs(dy))) + 4) / 6;
+					pixelMap[nx][ny].color = cc_arrayToRgbString(cc_scaleList(scaledColor, n));
+				}
+			}
+		}
+	}
 }
 
 var addDisplayCallback = function(pixel, pins, w, h) {
@@ -1228,13 +1379,13 @@ var addDisplayCallback = function(pixel, pins, w, h) {
 }
 
 elements.simple_seven_segment_display = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
-			[-1, 1, true],  // D0
-			[-1, 3, true],  // D1
-			[-1, 5, true],  // D2
-			[-1, 7, true],   // D3
+			[-1, 7, true],
+			[-1, 5, true],
+			[-1, 3, true],
+			[-1, 1, true],
 		];
 
 		initializeCircuit(pixel, pins, 5, 9, false, pixel.circuitRotation, addDisplayCallback);
@@ -1270,18 +1421,18 @@ elements.simple_seven_segment_display = {
 };
 
 elements.simple_double_seven_segment_display = {
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var pins = [
 			// Data inputs (D0-D3)
-			[-1, 1, true],  // D0
-			[-1, 3, true],  // D1
-			[-1, 5, true],  // D2
-			[-1, 7, true],   // D3
+			[-1, 7, true],
+			[-1, 5, true],
+			[-1, 3, true],
+			[-1, 1, true],
 
-			[1, -1, true],  // D2-0
-			[3, -1, true],  // D2-1
-			[5, -1, true],  // D2-2
-			[7, -1, true],   // D2-3
+			[7, -1, true],
+			[5, -1, true],
+			[3, -1, true],
+			[1, -1, true],
 		];
 
 		initializeCircuit(pixel, pins, 9, 9, false, pixel.circuitRotation, addDisplayCallback);
@@ -1337,6 +1488,117 @@ elements.simple_double_seven_segment_display = {
 	}
 };
 
+function general_display(w, h) {
+    return function(pixel) {
+        var pins = [];
+
+        // X input (X0-Xn)
+        for (var i = 0; i < Math.ceil(Math.log2(w)); i++) {
+            pins.push([-1, (Math.ceil(Math.log2(w)) - i) * 2 - 1, true]);
+        }
+
+        // Y input (Y0-Yn)
+        for (var i = 0; i < Math.ceil(Math.log2(h)); i++) {
+            pins.push([(Math.ceil(Math.log2(h)) - i) * 2 - 1, -1, true]);
+        }
+
+        // Color input
+        pins.push([11, -1, true]);
+
+        // Reset pin
+        pins.push([13, -1, true]);
+
+        // Clock input
+        pins.push([15, -1, true]);
+
+        // Initialize the circuit with the necessary pins
+        initializeCircuit(pixel, pins, w + 2, h + 2, false, pixel.circuitRotation, addDisplayCallback);
+
+        // Read inputs
+        var X = [];
+        for (var i = 0; i < Math.ceil(Math.log2(w)); i++) {
+            X.push(checkPin(pixel, pins, i));
+        }
+
+        var Y = [];
+        for (var i = 0; i < Math.ceil(Math.log2(h)); i++) {
+            Y.push(checkPin(pixel, pins, Math.ceil(Math.log2(w)) + i));
+        }
+
+        var color = checkPin(pixel, pins, pins.length - 3);
+        var reset = checkPin(pixel, pins, pins.length - 2);
+        var clock = checkPin(pixel, pins, pins.length - 1);
+
+        // Decode X and Y inputs to determine the pixel position
+        var x_pos = 0;
+        for (var i = 0; i < X.length; i++) {
+            x_pos += (X[i] ? 1 : 0) << i;
+        }
+
+        var y_pos = 0;
+        for (var i = 0; i < Y.length; i++) {
+            y_pos += (Y[i] ? 1 : 0) << i;
+        }
+
+        // Display dimension check
+        if (x_pos >= w || y_pos >= h) return;
+
+        var px = pixel.x + 1 + x_pos; // Adjust for the display position
+        var py = pixel.y + 1 + y_pos;
+
+        // Handle reset functionality
+        if (reset) {
+            for (var y = 1; y <= h; y++) {
+                for (var x = 1; x <= w; x++) {
+                    var reset_px = pixel.x + x;
+                    var reset_py = pixel.y + y;
+                    if (pixelMap[reset_px] && pixelMap[reset_px][reset_py] && pixelMap[reset_px][reset_py].element == "art") {
+                        pixelMap[reset_px][reset_py].color = "rgb(16, 230, 120)";
+                    }
+                }
+            }
+            return;
+        }
+
+        // Update display on clock pulse
+        if (clock) {
+            if (pixelMap[px] && pixelMap[px][py] && pixelMap[px][py].element == "art") {
+                // Set the pixel color
+                pixelMap[px][py].color = color ? "rgb(16, 230, 120)" : "rgb(16, 230, 120)";
+            }
+        }
+    };
+}
+
+elements.basic_mono_display_8x8 = {
+    cc_stableTick: general_display(8, 8),
+};
+
+elements.basic_mono_display_16x8 = {
+    cc_stableTick: general_display(16, 8),
+};
+
+elements.basic_mono_display_16x16 = {
+    cc_stableTick: general_display(16, 16),
+};
+
+elements.basic_mono_display_32x16 = {
+    cc_stableTick: general_display(32, 16),
+};
+
+elements.basic_mono_display_32x32 = {
+    cc_stableTick: general_display(32, 32),
+};
+
+elements.basic_mono_display_64x32 = {
+    cc_stableTick: general_display(64, 32),
+};
+
+elements.basic_mono_display_64x64 = {
+    cc_stableTick: general_display(64, 64),
+};
+
+
 function malfunction_chip(pixel) {
 	var emptySpaces = [];
 
@@ -1367,6 +1629,19 @@ function malfunction_chip(pixel) {
 	}
 }
 
+//elements.display = {
+//	color: "#444444",
+//	category: "logic",
+//	state: "solid",
+//	behavior: behaviors.WALL,
+//	hoverStat: function(pixel) {
+//		return `Circuit: ${pixel.corePosition}`;
+//	},
+//	cc_stableTick: function(pixel) {
+//
+//	}
+//};
+
 elements.circuit_material = {
 	color: "#444444",
 	category: "logic",
@@ -1375,9 +1650,9 @@ elements.circuit_material = {
 	hoverStat: function(pixel) {
 		return `Circuit: ${pixel.corePosition}`;
 	},
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		// Make it that extreme temperatures can stop the chip from working (for realism)
-		if (Math.random() < 0.003) {  // Chance to check for temperature or nearby particles
+		if (Math.random() < 0.003 && cc_setting1.value) {  // Chance to check for temperature or nearby particles
 			// Check temperature
 			if (pixel.temp > 120) {
 				// Replace the circuit core with lead if overheating
@@ -1415,7 +1690,7 @@ elements.input_pin = {
 	stateHigh: "lead",
 	tempHigh: 570,
 	behavior: behaviors.WALL,
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		pixel.active = false;
 		var neighbors = getNeighbors(pixel);
 		for (var i = 0;i < neighbors.length;i++) {
@@ -1436,7 +1711,7 @@ elements.output_pin = {
 	stateHigh: "lead",
 	tempHigh: 570,
 	behavior: behaviors.WALL,
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var neighbors = getNeighbors(pixel);
 		for (var i = 0;i < neighbors.length;i++) {
 			var neighbor = neighbors[i];
@@ -1482,7 +1757,7 @@ elements.logic_corrupt = {
 elements.logic_corrupter_machine = {
 	color: "#DD33DD",
 	category: "logic",
-	tick: function(pixel) {
+	cc_stableTick: function(pixel) {
 		var radius = 10
 		for (var y = pixel.y - radius; y < pixel.y + radius; y++) {
 			for (var x = pixel.x - radius; x < pixel.x + radius; x++) {
@@ -1528,6 +1803,7 @@ var circuits = [
 	{ circuit: elements.four_bit_enabler_circuit, color: cc_BROWN, size: [9, 3, true] },
 	{ circuit: elements.randomizer, color: cc_BROWN },
 	{ circuit: elements.four_bit_randomizer_circuit, color: cc_BROWN, size: [9, 3, true] },
+	{ circuit: elements.temperature_sensor, color: cc_BROWN },
 	// ROM/RAM: red
 //	{ circuit: elements.ROM_circuit, color: cc_RED, size: [18, 18, false] },
 	// Encoders and de-multiplexers: orange
@@ -1572,23 +1848,32 @@ var circuits = [
 	{ circuit: elements.medium_clock },
 	{ circuit: elements.fast_clock },
 	{ circuit: elements.very_fast_clock },
-	{ circuit: elements.very_fast_clock },
 	// Displays/visual circuits: white
 	{ circuit: elements.simple_seven_segment_display, color: cc_WHITE, size: [5, 9, false] },
 	{ circuit: elements.simple_double_seven_segment_display, color: cc_WHITE, size: [9, 9, false] },
+	{ circuit: elements.custom_RGB_led, color: cc_WHITE, size: [3, 3, true] },
+	{ circuit: elements.basic_mono_display_8x8, color: cc_WHITE, size: [10, 10, false] },
+	{ circuit: elements.basic_mono_display_16x8, color: cc_WHITE, size: [18, 10, false] },
+	{ circuit: elements.basic_mono_display_16x16, color: cc_WHITE, size: [18, 18, false] },
+	{ circuit: elements.basic_mono_display_32x16, color: cc_WHITE, size: [34, 18, false] },
+	{ circuit: elements.basic_mono_display_32x32, color: cc_WHITE, size: [34, 34, false] },
+	{ circuit: elements.basic_mono_display_64x32, color: cc_WHITE, size: [66, 34, false] },
+	{ circuit: elements.basic_mono_display_64x64, color: cc_WHITE, size: [66, 66, false] },
 ];
 
 circuits.forEach(circuitInfo => {
 	if (circuitInfo.color) {circuitInfo.circuit.color = circuitInfo.color;}
 	circuitInfo.circuit.category = "logic";
 	circuitInfo.circuit.maxSize = 1;
+	circuitInfo.circuit.behavior = behaviors.WALL;
+	circuitInfo.circuit.state = "solid";
 	circuitInfo.circuit.isCircuitCore = true;
 	circuitInfo.circuit.previewSize = circuitInfo.size;
 
 	// Exclude circuits without a frame
 	if (circuitInfo.size) {
-		var previousCircuitTick = circuitInfo.circuit.tick;
-		circuitInfo.circuit.tick = function(pixel) {
+		var previousCircuitTick = circuitInfo.circuit.cc_stableTick;
+		circuitInfo.circuit.cc_stableTick = function(pixel) {
 			previousCircuitTick(pixel);
 
 			// Don't constantly check
@@ -1606,7 +1891,10 @@ circuits.forEach(circuitInfo => {
 					deletePixel(pixel.x, pixel.y);
 				}
 
-				pixel.temp += Math.random(0, 5);
+				// Check if circuit overheating is enabled
+				if (cc_setting1.value) {
+					pixel.temp += Math.random(0.5);
+				}
 			}
 		}
 	}
@@ -1658,12 +1946,16 @@ function drawCircuitExtras() {
 	}
 }
 
-runAfterLoad(() => {
-	var originalDrawPixels3 = drawPixels;
-	drawPixels = function(forceTick=false) {
-		originalDrawPixels3(forceTick);
-		drawCircuitExtras();
-		return true;
-	};
-});
-resetInterval(tps);
+function runLogicTick() {
+	for (var i = 0;i < currentPixels.length;i++) {
+		var pixel = currentPixels[i];
+		if (elements[pixel.element].category == "logic") {
+			if (elements[pixel.element].cc_stableTick) {
+				elements[pixel.element].cc_stableTick(pixel);
+			}
+		}
+	}
+}
+
+renderPostPixel(drawCircuitExtras);
+runEveryTick(runLogicTick);
diff --git a/mods/mod_for_mnem.js b/mods/mod_for_mnem.js
new file mode 100644
index 00000000..2766d904
--- /dev/null
+++ b/mods/mod_for_mnem.js
@@ -0,0 +1 @@
+Object.keys(elements).forEach((element)=>{if (elements[element].category == "life") {delete elements[element]}})
\ No newline at end of file
diff --git a/mods/wifi_draw.js b/mods/wifi_draw.js
index bd20c247..41bf5ad1 100644
--- a/mods/wifi_draw.js
+++ b/mods/wifi_draw.js
@@ -1,14 +1,14 @@
 // RedBirdly's mod to draw lines between transmitters/receivers
-// logicgates.js required
+// logicgates.js or wifi.js required
 
 let logicReceivers = [];
 let logicTransmitters = [];
-// let receivers = [];
-// let transmitters = [];
+let receivers = [];
+let transmitters = [];
 
 function updateLogicLists() {
-    // receivers = [];
-    // transmitters = [];
+     receivers = [];
+     transmitters = [];
     logicReceivers = [];
 	logicTransmitters = [];
     
@@ -18,11 +18,11 @@ function updateLogicLists() {
             logicReceivers.push(pixel);
         } else if (pixel.element === "logic_transmitter") {
             logicTransmitters.push(pixel);
-        } /*else if (pixel.element === "receiver") {
+        } else if (pixel.element === "receiver") {
             receivers.push(pixel);
         } else if (pixel.element === "transmitter") {
             transmitters.push(pixel);
-        }*/
+        }
     }
 }
 
@@ -67,12 +67,21 @@ function drawLinks() {
             }
         }
     }
+
+    // Iterate through transmitters and receivers to draw lines for linked channels
+    for (const transmitter of transmitters) {
+        for (const receiver of receivers) {
+            if (transmitter._channel === receiver._channel) {
+                ctx.beginPath();
+                ctx.moveTo(transmitter.x * pixelSize + pixelSizeHalf, transmitter.y * pixelSize + pixelSizeHalf);
+                ctx.lineTo(receiver.x * pixelSize + pixelSizeHalf, receiver.y * pixelSize + pixelSizeHalf);
+                ctx.strokeStyle = "RGBA(0,0,255,0.2)";
+                ctx.lineWidth = 2;
+                ctx.stroke();
+            }
+        }
+    }
 }
 
-var originalDrawPixels2 = drawPixels;
-drawPixels = function(forceTick=false) {
-    originalDrawPixels2(forceTick);
-    updateLogicLists();
-    drawLinks();
-};
-resetInterval(tps);
+renderPostPixel(updateLogicLists);
+renderPostPixel(drawLinks);