diff --git a/mods/fire/README.txt b/mods/fire/README.txt
index 14022f0..099da1c 100644
--- a/mods/fire/README.txt
+++ b/mods/fire/README.txt
@@ -1,36 +1,35 @@
 Minetest Game mod: fire
 =======================
+See license.txt for license information.
 
-License of source code:
------------------------
-Copyright (C) 2012 Perttu Ahola (celeron55) <celeron55@gmail.com>
+Authors of source code
+----------------------
+Originally by Perttu Ahola (celeron55) <celeron55@gmail.com> (LGPL 2.1)
+Various Minetest developers and contributors (LGPL 2.1)
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-http://www.gnu.org/licenses/lgpl-2.1.html
-
-License of media (textures and sounds)
+Authors of media (textures and sounds)
 --------------------------------------
-Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)                                 
-http://creativecommons.org/licenses/by-sa/3.0/
-
-Authors of media files
------------------------
 Everything not listed in here:
-Copyright (C) 2012 Perttu Ahola (celeron55) <celeron55@gmail.com>
+Copyright (C) 2012 Perttu Ahola (celeron55) <celeron55@gmail.com> (CC BY-SA 3.0)
 
-fire_small.ogg sampled from:
-  http://www.freesound.org/people/dobroide/sounds/4211/
+Muadtralk (CC BY-SA 3.0)
+  fire_basic_flame_animated.png
 
-fire_large.ogg sampled from:
-  http://www.freesound.org/people/Dynamicell/sounds/17548/
+Gambit (CC BY-SA 3.0)
+  fire_flint_steel.png
 
-fire_basic_flame_animated.png:
-  Muadtralk
+dobroide (CC BY 3.0)
+http://www.freesound.org/people/dobroide/sounds/4211/
+  fire_small.ogg
 
-fire_flint_steel.png
-  Gambit (WTFPL)
+Dynamicell (CC BY 3.0)
+http://www.freesound.org/people/Dynamicell/sounds/17548/
+  fire_large.ogg
+  fire_fire.*.ogg
 
+fire_small.ogg and fire_large.ogg are unused but kept temporarily to not break
+other mods that may use them.
+
+Benboncan (CC BY 3.0)
+https://www.freesound.org/people/Benboncan/sounds/66457/
+  fire_flint_and_steel.ogg
diff --git a/mods/fire/depends.txt b/mods/fire/depends.txt
new file mode 100644
index 0000000..4ad96d5
--- /dev/null
+++ b/mods/fire/depends.txt
@@ -0,0 +1 @@
+default
diff --git a/mods/fire/init.lua b/mods/fire/init.lua
index 457f6b5..bee487a 100644
--- a/mods/fire/init.lua
+++ b/mods/fire/init.lua
@@ -1,11 +1,13 @@
--- minetest/fire/init.lua
-
 -- Global namespace for functions
 
 fire = {}
 
 
--- Register flame nodes
+--
+-- Items
+--
+
+-- Flame nodes
 
 minetest.register_node("fire:basic_flame", {
 	drawtype = "firelike",
@@ -28,18 +30,23 @@ minetest.register_node("fire:basic_flame", {
 	sunlight_propagates = true,
 	damage_per_second = 4,
 	groups = {igniter = 2, dig_immediate = 3, not_in_creative_inventory = 1},
+	on_timer = function(pos)
+		local f = minetest.find_node_near(pos, 1, {"group:flammable"})
+		if not f then
+			minetest.remove_node(pos)
+			return
+		end
+		-- Restart timer
+		return true
+	end,
 	drop = "",
 
 	on_construct = function(pos)
-		minetest.after(0, fire.on_flame_add_at, pos)
+		minetest.get_node_timer(pos):start(math.random(30, 60))
 	end,
 
-	on_destruct = function(pos)
-		minetest.after(0, fire.on_flame_remove_at, pos)
+	on_blast = function() -- Unaffected by explosions
 	end,
-
-	on_blast = function()
-	end, -- unaffected by explosions
 })
 
 minetest.register_node("fire:permanent_flame", {
@@ -66,31 +73,50 @@ minetest.register_node("fire:permanent_flame", {
 	groups = {igniter = 2, dig_immediate = 3},
 	drop = "",
 
-	on_blast = function()
+	on_blast = function() -- Unaffected by explosions
 	end,
 })
 
+
+-- Flint and steel
+
 minetest.register_tool("fire:flint_and_steel", {
 	description = "Flint and Steel",
 	inventory_image = "fire_flint_steel.png",
+	sound = {breaks = "default_tool_breaks"},
+
 	on_use = function(itemstack, user, pointed_thing)
-		local player_name = user:get_player_name()
 		local pt = pointed_thing
-
-		if pt.type == "node" and minetest.get_node(pt.above).name == "air" then
-			itemstack:add_wear(1000)
+		minetest.sound_play(
+			"fire_flint_and_steel",
+			{pos = pt.above, gain = 0.5, max_hear_distance = 8}
+		)
+		if pt.type == "node" then
 			local node_under = minetest.get_node(pt.under).name
-
-			if minetest.get_item_group(node_under, "flammable") >= 1 then
-				if not minetest.is_protected(pt.above, player_name) then
-					minetest.set_node(pt.above, {name = "fire:basic_flame"})
-				else
-					minetest.chat_send_player(player_name, "This area is protected")
-				end
+			local nodedef = minetest.registered_nodes[node_under]
+			if not nodedef then
+				return
+			end
+			local player_name = user:get_player_name()
+			if minetest.is_protected(pt.under, player_name) then
+				minetest.chat_send_player(player_name, "This area is protected")
+				return
+			end
+			if nodedef.on_ignite then
+				nodedef.on_ignite(pt.under, user)
+			elseif minetest.get_item_group(node_under, "flammable") >= 1
+					and minetest.get_node(pt.above).name == "air" then
+				minetest.set_node(pt.above, {name = "fire:basic_flame"})
 			end
 		end
-
 		if not minetest.setting_getbool("creative_mode") then
+			-- Wear tool
+			local wdef = itemstack:get_definition()
+			itemstack:add_wear(1000)
+			-- Tool break sound
+			if itemstack:get_count() == 0 and wdef.sound and wdef.sound.breaks then
+				minetest.sound_play(wdef.sound.breaks, {pos = pt.above, gain = 0.5})
+			end
 			return itemstack
 		end
 	end
@@ -103,210 +129,237 @@ minetest.register_craft({
 	}
 })
 
--- Get sound area of position
 
-fire.D = 6 -- size of sound areas
+-- Override coalblock to enable permanent flame above
+-- Coalblock is non-flammable to avoid unwanted basic_flame nodes
 
-function fire.get_area_p0p1(pos)
-	local p0 = {
-		x = math.floor(pos.x / fire.D) * fire.D,
-		y = math.floor(pos.y / fire.D) * fire.D,
-		z = math.floor(pos.z / fire.D) * fire.D,
-	}
-	local p1 = {
-		x = p0.x + fire.D - 1,
-		y = p0.y + fire.D - 1,
-		z = p0.z + fire.D - 1
-	}
-	return p0, p1
+minetest.override_item("default:coalblock", {
+	after_destruct = function(pos, oldnode)
+		pos.y = pos.y + 1
+		if minetest.get_node(pos).name == "fire:permanent_flame" then
+			minetest.remove_node(pos)
+		end
+	end,
+	on_ignite = function(pos, igniter)
+		local flame_pos = {x = pos.x, y = pos.y + 1, z = pos.z}
+		if minetest.get_node(flame_pos).name == "air" then
+			minetest.set_node(flame_pos, {name = "fire:permanent_flame"})
+		end
+	end,
+})
+
+
+--
+-- Sound
+--
+
+local flame_sound = minetest.setting_getbool("flame_sound")
+if flame_sound == nil then
+	-- Enable if no setting present
+	flame_sound = true
+end
+
+if flame_sound then
+
+	local handles = {}
+	local timer = 0
+
+	-- Parameters
+
+	local radius = 8 -- Flame node search radius around player
+	local cycle = 3 -- Cycle time for sound updates
+
+	-- Update sound for player
+
+	function fire.update_player_sound(player)
+		local player_name = player:get_player_name()
+		-- Search for flame nodes in radius around player
+		local ppos = player:getpos()
+		local areamin = vector.subtract(ppos, radius)
+		local areamax = vector.add(ppos, radius)
+		local fpos, num = minetest.find_nodes_in_area(
+			areamin,
+			areamax,
+			{"fire:basic_flame", "fire:permanent_flame"}
+		)
+		-- Total number of flames in radius
+		local flames = (num["fire:basic_flame"] or 0) +
+			(num["fire:permanent_flame"] or 0)
+		-- Stop previous sound
+		if handles[player_name] then
+			minetest.sound_stop(handles[player_name])
+			handles[player_name] = nil
+		end
+		-- If flames
+		if flames > 0 then
+			-- Find centre of flame positions
+			local fposmid = fpos[1]
+			-- If more than 1 flame
+			if #fpos > 1 then
+				local fposmin = areamax
+				local fposmax = areamin
+				for i = 1, #fpos do
+					local fposi = fpos[i]
+					if fposi.x > fposmax.x then
+						fposmax.x = fposi.x
+					end
+					if fposi.y > fposmax.y then
+						fposmax.y = fposi.y
+					end
+					if fposi.z > fposmax.z then
+						fposmax.z = fposi.z
+					end
+					if fposi.x < fposmin.x then
+						fposmin.x = fposi.x
+					end
+					if fposi.y < fposmin.y then
+						fposmin.y = fposi.y
+					end
+					if fposi.z < fposmin.z then
+						fposmin.z = fposi.z
+					end
+				end
+				fposmid = vector.divide(vector.add(fposmin, fposmax), 2)
+			end
+			-- Play sound
+			local handle = minetest.sound_play(
+				"fire_fire",
+				{
+					pos = fposmid,
+					to_player = player_name,
+					gain = math.min(0.06 * (1 + flames * 0.125), 0.18),
+					max_hear_distance = 32,
+					loop = true, -- In case of lag
+				}
+			)
+			-- Store sound handle for this player
+			if handle then
+				handles[player_name] = handle
+			end
+		end
+	end
+
+	-- Cycle for updating players sounds
+
+	minetest.register_globalstep(function(dtime)
+		timer = timer + dtime
+		if timer < cycle then
+			return
+		end
+
+		timer = 0
+		local players = minetest.get_connected_players()
+		for n = 1, #players do
+			fire.update_player_sound(players[n])
+		end
+	end)
+
+	-- Stop sound and clear handle on player leave
+
+	minetest.register_on_leaveplayer(function(player)
+		local player_name = player:get_player_name()
+		if handles[player_name] then
+			minetest.sound_stop(handles[player_name])
+			handles[player_name] = nil
+		end
+	end)
 end
 
 
--- Fire sounds table
--- key: position hash of low corner of area
--- value: {handle=sound handle, name=sound name}
-fire.sounds = {}
-
-
--- Update fire sounds in sound area of position
+-- Deprecated function kept temporarily to avoid crashes if mod fire nodes call it
 
 function fire.update_sounds_around(pos)
-	local p0, p1 = fire.get_area_p0p1(pos)
-	local cp = {x = (p0.x + p1.x) / 2, y = (p0.y + p1.y) / 2, z = (p0.z + p1.z) / 2}
-	local flames_p = minetest.find_nodes_in_area(p0, p1, {"fire:basic_flame"})
-	--print("number of flames at "..minetest.pos_to_string(p0).."/"
-	--		..minetest.pos_to_string(p1)..": "..#flames_p)
-	local should_have_sound = (#flames_p > 0)
-	local wanted_sound = nil
-	if #flames_p >= 9 then
-		wanted_sound = {name = "fire_large", gain = 0.7}
-	elseif #flames_p > 0 then
-		wanted_sound = {name = "fire_small", gain = 0.9}
-	end
-	local p0_hash = minetest.hash_node_position(p0)
-	local sound = fire.sounds[p0_hash]
-	if not sound then
-		if should_have_sound then
-			fire.sounds[p0_hash] = {
-				handle = minetest.sound_play(wanted_sound,
-					{pos = cp, max_hear_distance = 16, loop = true}),
-				name = wanted_sound.name,
-			}
-		end
-	else
-		if not wanted_sound then
-			minetest.sound_stop(sound.handle)
-			fire.sounds[p0_hash] = nil
-		elseif sound.name ~= wanted_sound.name then
-			minetest.sound_stop(sound.handle)
-			fire.sounds[p0_hash] = {
-				handle = minetest.sound_play(wanted_sound,
-					{pos = cp, max_hear_distance = 16, loop = true}),
-				name = wanted_sound.name,
-			}
-		end
-	end
 end
 
 
--- Update fire sounds on flame node construct or destruct
-
-function fire.on_flame_add_at(pos)
-	fire.update_sounds_around(pos)
-end
-
-
-function fire.on_flame_remove_at(pos)
-	fire.update_sounds_around(pos)
-end
-
-
--- Return positions for flames around a burning node
-
-function fire.find_pos_for_flame_around(pos)
-	return minetest.find_node_near(pos, 1, {"air"})
-end
-
-
--- Detect nearby extinguishing nodes
-
-function fire.flame_should_extinguish(pos)
-	return minetest.find_node_near(pos, 1, {"group:puts_out_fire"})
-end
-
+--
+-- ABMs
+--
 
 -- Extinguish all flames quickly with water, snow, ice
 
 minetest.register_abm({
+	label = "Extinguish flame",
 	nodenames = {"fire:basic_flame", "fire:permanent_flame"},
 	neighbors = {"group:puts_out_fire"},
 	interval = 3,
 	chance = 1,
 	catch_up = false,
-	action = function(p0, node, _, _)
-		minetest.remove_node(p0)
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		minetest.remove_node(pos)
 		minetest.sound_play("fire_extinguish_flame",
-			{pos = p0, max_hear_distance = 16, gain = 0.25})
+			{pos = pos, max_hear_distance = 16, gain = 0.15})
 	end,
 })
 
 
--- Enable the following ABMs according to 'disable fire' setting
+-- Enable the following ABMs according to 'enable fire' setting
 
-if minetest.setting_getbool("disable_fire") then
+local fire_enabled = minetest.setting_getbool("enable_fire")
+if fire_enabled == nil then
+	-- New setting not specified, check for old setting.
+	-- If old setting is also not specified, 'not nil' is true.
+	fire_enabled = not minetest.setting_getbool("disable_fire")
+end
 
-	-- Remove basic flames only
+if not fire_enabled then
+
+	-- Remove basic flames only if fire disabled
 
 	minetest.register_abm({
+		label = "Remove disabled fire",
 		nodenames = {"fire:basic_flame"},
 		interval = 7,
 		chance = 1,
 		catch_up = false,
-		action = function(p0, node, _, _)
-			minetest.remove_node(p0)
-		end,
+		action = minetest.remove_node,
 	})
 
-else
+else -- Fire enabled
 
 	-- Ignite neighboring nodes, add basic flames
 
 	minetest.register_abm({
+		label = "Ignite flame",
 		nodenames = {"group:flammable"},
 		neighbors = {"group:igniter"},
 		interval = 7,
 		chance = 12,
 		catch_up = false,
-		action = function(p0, node, _, _)
+		action = function(pos, node, active_object_count, active_object_count_wider)
 			-- If there is water or stuff like that around node, don't ignite
-			if fire.flame_should_extinguish(p0) then
+			if minetest.find_node_near(pos, 1, {"group:puts_out_fire"}) then
 				return
 			end
-			local p = fire.find_pos_for_flame_around(p0)
+			local p = minetest.find_node_near(pos, 1, {"air"})
 			if p then
 				minetest.set_node(p, {name = "fire:basic_flame"})
 			end
 		end,
 	})
 
-	-- Remove basic flames and flammable nodes
+	-- Remove flammable nodes around basic flame
 
 	minetest.register_abm({
+		label = "Remove flammable nodes",
 		nodenames = {"fire:basic_flame"},
+		neighbors = "group:flammable",
 		interval = 5,
-		chance = 6,
+		chance = 18,
 		catch_up = false,
-		action = function(p0, node, _, _)
-			-- If there are no flammable nodes around flame, remove flame
-			local p = minetest.find_node_near(p0, 1, {"group:flammable"})
-			if not p then
-				minetest.remove_node(p0)
-				return
-			end
-			if math.random(1, 3) == 1 then
-				-- remove flammable nodes around flame
-				local node = minetest.get_node(p)
-				local def = minetest.registered_nodes[node.name]
+		action = function(pos, node, active_object_count, active_object_count_wider)
+			local p = minetest.find_node_near(pos, 1, {"group:flammable"})
+			if p then
+				local flammable_node = minetest.get_node(p)
+				local def = minetest.registered_nodes[flammable_node.name]
 				if def.on_burn then
 					def.on_burn(p)
 				else
 					minetest.remove_node(p)
-					nodeupdate(p)
+					minetest.check_for_falling(p)
 				end
 			end
 		end,
 	})
 
 end
-
-
--- Rarely ignite things from far
-
---[[ Currently disabled to reduce the chance of uncontrollable spreading
-	fires that disrupt servers. Also for less lua processing load.
-
-minetest.register_abm({
-	nodenames = {"group:igniter"},
-	neighbors = {"air"},
-	interval = 5,
-	chance = 10,
-	action = function(p0, node, _, _)
-		local reg = minetest.registered_nodes[node.name]
-		if not reg or not reg.groups.igniter or reg.groups.igniter < 2 then
-			return
-		end
-		local d = reg.groups.igniter
-		local p = minetest.find_node_near(p0, d, {"group:flammable"})
-		if p then
-			-- If there is water or stuff like that around flame, don't ignite
-			if fire.flame_should_extinguish(p) then
-				return
-			end
-			local p2 = fire.find_pos_for_flame_around(p)
-			if p2 then
-				minetest.set_node(p2, {name = "fire:basic_flame"})
-			end
-		end
-	end,
-})
---]]
diff --git a/mods/fire/license.txt b/mods/fire/license.txt
new file mode 100644
index 0000000..43f9cd7
--- /dev/null
+++ b/mods/fire/license.txt
@@ -0,0 +1,84 @@
+License of source code
+----------------------
+
+GNU Lesser General Public License, version 2.1
+Copyright (C) 2012-2016 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2012-2016 Various Minetest developers and contributors
+
+This program is free software; you can redistribute it and/or modify it under the terms
+of the GNU Lesser General Public License as published by the Free Software Foundation;
+either version 2.1 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Lesser General Public License for more details:
+https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+
+
+Licenses of media (textures and sounds)
+---------------------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2012-2016 Perttu Ahola (celeron55) <celeron55@gmail.com>
+Copyright (C) 2012-2016 Muadtralk
+Copyright (C) 2013-2016 Gambit
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/
+
+-----------------------
+
+Attribution 3.0 Unported (CC BY 3.0)
+Copyright (C) 2005 dobroide
+Copyright (C) 2006 Dynamicell
+Copyright (C) 2009 Benboncan
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by/3.0/
diff --git a/mods/fire/sounds/fire_fire.1.ogg b/mods/fire/sounds/fire_fire.1.ogg
new file mode 100644
index 0000000..cbfee4c
Binary files /dev/null and b/mods/fire/sounds/fire_fire.1.ogg differ
diff --git a/mods/fire/sounds/fire_fire.2.ogg b/mods/fire/sounds/fire_fire.2.ogg
new file mode 100644
index 0000000..e8d0eb1
Binary files /dev/null and b/mods/fire/sounds/fire_fire.2.ogg differ
diff --git a/mods/fire/sounds/fire_fire.3.ogg b/mods/fire/sounds/fire_fire.3.ogg
new file mode 100644
index 0000000..5cad3d9
Binary files /dev/null and b/mods/fire/sounds/fire_fire.3.ogg differ
diff --git a/mods/fire/sounds/fire_flint_and_steel.ogg b/mods/fire/sounds/fire_flint_and_steel.ogg
new file mode 100644
index 0000000..6996e16
Binary files /dev/null and b/mods/fire/sounds/fire_flint_and_steel.ogg differ