diff --git a/.rubocop.yml b/.rubocop.yml
index 68cce3128..0b59a1151 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -197,6 +197,7 @@ Style/Lambda:
     - 'language/lambda_spec.rb'
     - 'language/proc_spec.rb'
     - 'language/numbered_parameters_spec.rb'
+    - 'language/it_parameter_spec.rb'
     - 'core/kernel/lambda_spec.rb'
 
 Style/EmptyLambdaParameter:
diff --git a/core/proc/parameters_spec.rb b/core/proc/parameters_spec.rb
index e9bc9a1c5..f1fe00c35 100644
--- a/core/proc/parameters_spec.rb
+++ b/core/proc/parameters_spec.rb
@@ -158,4 +158,11 @@
   it "returns :nokey for **nil parameter" do
     proc { |**nil| }.parameters.should == [[:nokey]]
   end
+
+  ruby_version_is "3.4" do
+    it "handles the usage of `it` as a paramater" do
+      eval("proc { it }").parameters.should == [[:opt, nil]]
+      eval("lambda { it }").parameters.should == [[:req]]
+    end
+  end
 end
diff --git a/language/block_spec.rb b/language/block_spec.rb
index e1e4a363c..cc003b894 100644
--- a/language/block_spec.rb
+++ b/language/block_spec.rb
@@ -1049,6 +1049,12 @@ def all_kwrest(arg1, arg2, *rest, post1, post2, kw1: 1, kw2: 2, okw1:, okw2:, **
       }.should complain(/warning: `it` calls without arguments will refer to the first block param in Ruby 3.4; use it\(\) or self.it/)
     end
 
+    it "emits a deprecation warning if numbered parameters are used" do
+      -> {
+        eval "proc { it; _1 }"
+      }.should complain(/warning: `it` calls without arguments will refer to the first block param in Ruby 3.4; use it\(\) or self.it/)
+    end
+
     it "does not emit a deprecation warning when a block has parameters" do
       -> { eval "proc { |a, b| it }" }.should_not complain
       -> { eval "proc { |*rest| it }" }.should_not complain
@@ -1058,21 +1064,75 @@ def all_kwrest(arg1, arg2, *rest, post1, post2, kw1: 1, kw2: 2, okw1:, okw2:, **
       -> { eval "proc { |**| it }" }.should_not complain
       -> { eval "proc { |&block| it }" }.should_not complain
       -> { eval "proc { |&| it }" }.should_not complain
+      -> { eval "proc { || it }" }.should_not complain
     end
 
     it "does not emit a deprecation warning when `it` calls with arguments" do
       -> { eval "proc { it(42) }" }.should_not complain
+      -> { eval "proc { it 42 }" }.should_not complain
+    end
+
+    it "does not emit a deprecation warning when `it` calls with a block" do
+      -> { eval "proc { it {} }" }.should_not complain
+    end
+
+    it "does not emit a deprecation warning when a local variable inside the block named `it` exists" do
+      -> { eval "proc { it = 42; it }" }.should_not complain
     end
 
     it "does not emit a deprecation warning when `it` calls with explicit empty arguments list" do
       -> { eval "proc { it() }" }.should_not complain
     end
+
+    it "calls the method `it` if defined" do
+      o = Object.new
+      def o.it
+        21
+      end
+      suppress_warning do
+        o.instance_eval("proc { it * 2 }").call(1).should == 42
+      end
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "does not emit a deprecation warning" do
+      -> {
+        eval "proc { it }"
+      }.should_not complain
+    end
+
+    it "acts as the first argument if no local variables exist" do
+      eval("proc { it * 2 }").call(5).should == 10
+    end
+
+    it "can be reassigned to act as a local variable" do
+      eval("proc { tmp = it; it = tmp * 2; it }").call(21).should == 42
+    end
+
+    it "can be used in nested calls" do
+      eval("proc { it.map { it * 2 } }").call([1, 2, 3]).should == [2, 4, 6]
+    end
+
+    it "cannot be mixed with numbered parameters" do
+      -> {
+        eval "proc { it + _1 }"
+      }.should raise_error(SyntaxError, /numbered parameters are not allowed when 'it' is already used|'it' is already used in/)
+
+      -> {
+        eval "proc { _1 + it }"
+      }.should raise_error(SyntaxError, /numbered parameter is already used in|'it' is not allowed when a numbered parameter is already used/)
+    end
   end
 end
 
-describe "if `it` is defined outside of a block" do
-  it "treats `it` as a captured variable" do
+describe "if `it` is defined as a variable" do
+  it "treats `it` as a captured variable if defined outside of a block" do
     it = 5
     proc { it }.call(0).should == 5
   end
+
+  it "treats `it` as a local variable if defined inside of a block" do
+    proc { it = 5; it }.call(0).should == 5
+  end
 end
diff --git a/language/it_parameter_spec.rb b/language/it_parameter_spec.rb
new file mode 100644
index 000000000..72023180d
--- /dev/null
+++ b/language/it_parameter_spec.rb
@@ -0,0 +1,66 @@
+require_relative '../spec_helper'
+
+ruby_version_is "3.4" do
+  describe "The `it` parameter" do
+    it "provides it in a block" do
+      -> { it }.call("a").should == "a"
+      proc { it }.call("a").should == "a"
+      lambda { it }.call("a").should == "a"
+      ["a"].map { it }.should == ["a"]
+    end
+
+    it "assigns nil to not passed parameters" do
+      proc { it }.call().should == nil
+    end
+
+    it "can be used in both outer and nested blocks at the same time" do
+      -> { it + -> { it * it }.call(2) }.call(3).should == 7
+    end
+
+    it "is a regular local variable if there is already a 'it' local variable" do
+        it = 0
+        proc { it }.call("a").should == 0
+    end
+
+    it "raises SyntaxError when block parameters are specified explicitly" do
+      -> { eval("-> () { it }")         }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+      -> { eval("-> (x) { it }")        }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+
+      -> { eval("proc { || it }")       }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+      -> { eval("proc { |x| it }")      }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+
+      -> { eval("lambda { || it }")     }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+      -> { eval("lambda { |x| it }")    }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+
+      -> { eval("['a'].map { || it }")  }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+      -> { eval("['a'].map { |x| it }") }.should raise_error(SyntaxError, /ordinary parameter is defined/)
+    end
+
+    it "affects block arity" do
+      -> {}.arity.should == 0
+      -> { it }.arity.should == 1
+    end
+
+    it "affects block parameters" do
+      -> { it }.parameters.should == [[:req]]
+
+      ruby_version_is ""..."4.0" do
+        proc { it }.parameters.should == [[:opt, nil]]
+      end
+      ruby_version_is "4.0" do
+        proc { it }.parameters.should == [[:opt]]
+      end
+    end
+
+    it "does not affect binding local variables" do
+      -> { it; binding.local_variables }.call("a").should == []
+    end
+
+    it "does not work in methods" do
+      obj = Object.new
+      def obj.foo; it; end
+
+      -> { obj.foo("a") }.should raise_error(ArgumentError, /wrong number of arguments/)
+    end
+  end
+end