Index: t/spec/S02-builtin_data_types/num.t
===================================================================
--- t/spec/S02-builtin_data_types/num.t	(revision 28151)
+++ t/spec/S02-builtin_data_types/num.t	(working copy)
@@ -19,7 +19,7 @@
 
 #L<S02/Built-In Data Types/Rat supports arbitrary precision rational arithmetic>
 {
-    my $a = 1 div 1;
+    my $a = 1 / 1;
     isa_ok($a, Rat);
     is($a, "1/1", '1.0 stringification works');
 }
@@ -91,7 +91,7 @@
 }
 #L<S02/Built-In Data Types/Rat supports arbitrary precision rational arithmetic>
 
-isa_ok(1 div 1, Rat);
+isa_ok(1 / 1, Rat);
 
 {
     my $a = 80000.0000000000000000000000000;
Index: t/spec/S02-builtin_data_types/declare.t
===================================================================
--- t/spec/S02-builtin_data_types/declare.t	(revision 28151)
+++ t/spec/S02-builtin_data_types/declare.t	(working copy)
@@ -29,7 +29,7 @@
 }
 
 {
- my Rat $namcu = 7 div 4;
+ my Rat $namcu = 7 / 4;
  isa_ok($namcu,Rat);
 }
 
@@ -148,7 +148,7 @@
 
 #?rakudo skip 'rat not implemented'
 {
- my rat $namcu = 7 div 4;
+ my rat $namcu = 7 / 4;
  isa_ok($namcu,rat);
 }
 
Index: t/spec/S02-builtin_data_types/type.t
===================================================================
--- t/spec/S02-builtin_data_types/type.t	(revision 28151)
+++ t/spec/S02-builtin_data_types/type.t	(working copy)
@@ -118,8 +118,8 @@
 {
     # the following two are the same type of behavior
     # S02: "It is possible for the of type to disagree with the as type"
-    my Rat sub returntype4 ($pass)     as Num {$pass ?? 11 div 10 !! 1}
-    my sub returntype5 ($pass --> Rat) as Num {$pass ?? 11 div  5 !! 2}
+    my Rat sub returntype4 ($pass)     as Num {$pass ?? 11 / 10 !! 1}
+    my sub returntype5 ($pass --> Rat) as Num {$pass ?? 11 /  5 !! 2}
 
     is(returntype4(True), 1.1, 'good return value works (my Type sub as OtherType)');
     eval_dies_ok('returntype4(False)', 'bad return value dies (my Type sub as OtherType)');
Index: t/spec/S32-temporal/Temporal.t
===================================================================
--- t/spec/S32-temporal/Temporal.t	(revision 28151)
+++ t/spec/S32-temporal/Temporal.t	(working copy)
@@ -31,7 +31,7 @@
     '2000-01-01 00:00:00 was on a Saturday in January'; # test 6
 
 $t  = time;
-$d  = (int($t/86400) + 4) % 7 + 1;
+$d  = (int($t / 86400) + 4) % 7 + 1;
 $g1 = Time.gmtime($t);
 $g2 = Time.gmtime;            # $g1 and $g2 might differ very occasionally
 ok  $g1.date.year  ==$g2.date.year   && $g1.date.month ==$g2.date.month &&
@@ -80,14 +80,18 @@
           time => Temporal::Time.new( :hour(@t[2]),      :minute(@t[1]),  :second(@t[0]) ),
           timezone => Temporal::TimeZone::Observance.new(
               offset=>-8*3600, isdst=>Bool::False, abbreviation=>'PDT' ) );
+             
 ok $g1.epoch == $t, "at $g1, epoch is {$g1.epoch}"; # test 17
 
+# All these "int()"s should be considered grotesque, but that make it 
+# work in Rakudo for now.
+
 # An independent calculation to cross check the Temporal algorithms.
 sub test_gmtime( Num $t is copy ) {
     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst);
-    $sec  = int($t) % 60; $t = int($t/60); # $t is now epoch minutes
-    $min  = $t % 60;      $t = int($t/60); # $t is now epoch hours
-    $hour = $t % 24;      $t = int($t/24); # $t is now epoch days
+    $sec  = int($t) % 60; $t = int(int($t) div 60); # $t is now epoch minutes
+    $min  = $t % 60;      $t = int($t div 60); # $t is now epoch hours
+    $hour = $t % 24;      $t = int($t div 24); # $t is now epoch days
     # Not a sophisticated or fast algorithm, just an understandable one
     # only valid from 1970-01-01 until 2100-02-28
     $wday = ($t+4) % 7;  # 1970-01-01 was a Thursday
Index: t/spec/S03-operators/assign.t
===================================================================
--- t/spec/S03-operators/assign.t	(revision 28151)
+++ t/spec/S03-operators/assign.t	(working copy)
@@ -297,10 +297,10 @@
 
 {
     my $x = 6;
-    @p = $x /= 3, 4;
-    is($x, 2, '/= operator');
-    is(@p[0],2, "/= operator parses as item assignment 1");
-    is(@p[1],4, "/= operator parses as item assignment 2");
+    @p = $x div= 3, 4;
+    is($x, 2, 'div= operator');
+    is(@p[0],2, "div= operator parses as item assignment 1");
+    is(@p[1],4, "div= operator parses as item assignment 2");
 }
 
 {
Index: t/spec/S03-operators/ternary.t
===================================================================
--- t/spec/S03-operators/ternary.t	(revision 28151)
+++ t/spec/S03-operators/ternary.t	(working copy)
@@ -21,7 +21,7 @@
 }
 
 is(($str2 eq $str1 ?? 8 * 8 !! 9 * 9), 64, "?? !! in parenthesis");
-is(($str2 eq $str3 ?? 8 + 8 !! 9 / 9), 1, "?? !! in parenthesis");
+is(($str2 eq $str3 ?? 8 + 8 !! 9 div 9), 1, "?? !! in parenthesis");
 
 is(1 ?? 2 ?? 3 !! 4 !! 5 ?? 6 !! 7, 3, "nested ?? !!");
 is(1 ?? 0 ?? 3 !! 4 !! 5 ?? 6 !! 7, 4, "nested ?? !!");
Index: t/spec/S03-operators/hyper.t
===================================================================
--- t/spec/S03-operators/hyper.t	(revision 28151)
+++ t/spec/S03-operators/hyper.t	(working copy)
@@ -35,7 +35,7 @@
         @e = ((1,1,1), (2,2), (3));
         is(~@r, ~@e, "hyper-xx two arrays");
 
-        @r = (20, 40, 60) »/« (2, 5, 10);
+        @r = (20, 40, 60) »div« (2, 5, 10);
         @e = (10, 8, 6);
         is(~@r, ~@e, "hyper-divide two arrays");
 
@@ -65,7 +65,7 @@
         @e = ((1,1,1), (2,2), (3));
         is(~@r, ~@e, "hyper-xx two arrays ASCII notation");
 
-        @r = (20, 40, 60) >>/<< (2, 5, 10);
+        @r = (20, 40, 60) >>div<< (2, 5, 10);
         @e = (10, 8, 6);
         is(~@r, ~@e, "hyper-divide two arrays ASCII notation");
 
Index: t/spec/S03-operators/basic-types.t
===================================================================
--- t/spec/S03-operators/basic-types.t	(revision 28151)
+++ t/spec/S03-operators/basic-types.t	(working copy)
@@ -64,7 +64,7 @@
 
 my $float = 0.5;
 isa_ok($float, Num, 'it is an Num type');
-isa_ok(1 div 4, Rat, 'infix:<div> produces a Rat');
+isa_ok(1 / 4, Rat, 'infix:</> of integers produces a Rat');
 
 my $string = "Hello World";
 isa_ok($string, Str, 'it is a Str type');
Index: t/spec/S03-operators/precedence.t
===================================================================
--- t/spec/S03-operators/precedence.t	(revision 28151)
+++ t/spec/S03-operators/precedence.t	(working copy)
@@ -13,7 +13,7 @@
 
 =end pod
 
-plan 54;
+plan 55;
 
 
 # terms
@@ -46,7 +46,8 @@
 # multiplicative
 
 is(4 + 3 * 2, 10, "* binds tighter than binary +");
-is(2 - 2 / 2, 1, "/ binds tighter than binary -");
+is(2 - 2 div 2, 1, "div binds tighter than binary -");
+is(2 - 2 / 2, 1 / 1, "/ binds tighter than binary -");
 
 # additive
 
Index: t/spec/S03-operators/arith.t
===================================================================
--- t/spec/S03-operators/arith.t	(revision 28151)
+++ t/spec/S03-operators/arith.t	(working copy)
@@ -2,7 +2,7 @@
 
 use Test;
 
-plan 199;
+plan 200;
 
 my $five = abs(-5);
 
@@ -263,16 +263,19 @@
 
 # divide
 
-tryeq 28/14, 2;
-tryeq 28/-7, -4;
-tryeq -28/4, -7;
-tryeq -28/-2, 14;
+tryeq 28 div 14, 2;
+tryeq 28 div -7, -4;
+tryeq -28 div 4, -7;
+tryeq -28 div -2, 14;
 
-tryeq 0x80000000/1, 0x80000000;
-tryeq 0x80000000/-1, -0x80000000;
-tryeq -0x80000000/1, -0x80000000;
-tryeq -0x80000000/-1, 0x80000000;
+tryeq 0x80000000 div 1, 0x80000000;
+tryeq 0x80000000 div -1, -0x80000000;
+tryeq -0x80000000 div 1, -0x80000000;
+tryeq -0x80000000 div -1, 0x80000000;
 
+#?rakudo todo '$x div $y == floor($x/$y)'
+is(9 div 4, 2, "9 div 4 == 2");
+
 # The example for sloppy divide, rigged to avoid the peephole optimiser.
 is_approx "20." / "5.", 4;
 
@@ -283,12 +286,12 @@
 
 # Bluuurg if your floating point can't accurately cope with powers of 2
 # [I suspect this is parsing string-to-float problems, not actual arith]
-is 18446744073709551616/1, 18446744073709551616; # Bluuurg
+is 18446744073709551616 div 1, 18446744073709551616; # Bluuurg
 
 {
-    tryeq_sloppy 18446744073709551616/2, 9223372036854775808;
-    tryeq_sloppy 18446744073709551616/4294967296, 4294967296;
-    tryeq_sloppy 18446744073709551616/9223372036854775808, 2;
+    tryeq_sloppy 18446744073709551616 div 2, 9223372036854775808;
+    tryeq_sloppy 18446744073709551616 div 4294967296, 4294967296;
+    tryeq_sloppy 18446744073709551616 div 9223372036854775808, 2;
 }
 
 {
@@ -323,7 +326,7 @@
 {
     is_approx(-1, (0 + 1i)**2, "i^2 == -1");
     is_approx(-1, (0.7071067811865476 + -0.7071067811865475i)**4, "sqrt(-i)**4 ==-1" );
-    is_approx(1i, (-1+0i)**(1/2), '(-1+0i)**(1/2) == i ');
+    is_approx(1i, (-1+0i)**(1 div 2), '(-1+0i)**(1/2) == i ');
 }
 
 {
@@ -335,16 +338,16 @@
     is Inf+100, Inf;
     is Inf-100, Inf;
     is Inf*100, Inf;
-    is Inf/100, Inf;
+    is Inf / 100, Inf;
     is Inf*-100, -Inf;
-    is Inf/-100, -Inf;
-    is 100/Inf, 0;
+    is Inf / -100, -Inf;
+    is 100 / Inf, 0;
     is Inf**100, Inf;
     is Inf*0, NaN;
     is Inf - Inf, NaN;
     is Inf*Inf, Inf;
-    is Inf/Inf, NaN;
-    is Inf*Inf/Inf, NaN;
+    is Inf / Inf, NaN;
+    is Inf*Inf / Inf, NaN;
     is Inf**0, 1;
     is 0**0, 1;
     is 0**Inf, 0;
@@ -373,18 +376,18 @@
     is NaN+100, NaN;
     is NaN-100, NaN;
     is NaN*100, NaN;
-    is NaN/100, NaN;
+    is NaN / 100, NaN;
     is NaN**100, NaN;
     is NaN+NaN, NaN;
     is NaN - NaN, NaN;
     is NaN*NaN, NaN;
-    is NaN/NaN, NaN;
+    is NaN / NaN, NaN;
 
     is NaN+Inf, NaN;
     is NaN - Inf, NaN;
     is NaN*Inf, NaN;
-    is NaN/Inf, NaN;
-    is Inf/NaN, NaN;
+    is NaN / Inf, NaN;
+    is Inf / NaN, NaN;
 
     my $nan1 = NaN**NaN;
     is $nan1, NaN, "NaN**NaN";
@@ -413,9 +416,9 @@
 dies_ok( { $x = 0; say 3 % $x; }, 'Modulo zero dies and is catchable with VInt/VRat variables');
 dies_ok( { $x := 0; say 3 % $x; }, 'Modulo zero dies and is catchable with VRef variables');
 
-dies_ok( { say 3 / 0 }, 'Division by zero dies and is catchable');
-dies_ok( { $x = 0; say 3 / $x; }, 'Division by zero dies and is catchable with VInt/VRat variables');
-dies_ok( { $x := 0; say 3 / $x; }, 'Division by zero dies and is catchable with VRef variables');
+dies_ok( { say 3 div 0 }, 'Division by zero dies and is catchable');
+dies_ok( { $x = 0; say 3 div $x; }, 'Division by zero dies and is catchable with VInt div VRat variables');
+dies_ok( { $x := 0; say 3 div $x; }, 'Division by zero dies and is catchable with VRef variables');
 
 # This is a rakudo regression wrt bignum:
 #?rakudo skip 'bigint'
Index: t/spec/integration/99problems-31-to-40.t
===================================================================
--- t/spec/integration/99problems-31-to-40.t	(revision 28151)
+++ t/spec/integration/99problems-31-to-40.t	(working copy)
@@ -147,7 +147,7 @@
         while $n > 1 {
           if $n % $cond == 0 {
     	$count++;
-    	$n /= $cond;
+    	$n div= $cond;
           }
           else {
     	if $count > 0 {
Index: t/spec/integration/99problems-51-to-60.t
===================================================================
--- t/spec/integration/99problems-51-to-60.t	(revision 28151)
+++ t/spec/integration/99problems-51-to-60.t	(working copy)
@@ -56,14 +56,14 @@
         return undef               if $n == 0;
         gather {
             if $n % 2 == 1 {
-                my $k = ($n - 1) / 2;
+                my $k = ($n - 1) div 2;
                 for cbal-tree($k) -> $a {
                     for cbal-tree($k) -> $b {
                         take ['x', $a, $b];
                     }
                 }
             } else {
-                my $k = $n / 2;
+                my $k = $n div 2;
                 for cbal-tree($k) -> $a {
                     for cbal-tree($k - 1) -> $b {
                         take ['x', $a, $b];
Index: t/spec/S32-num/rat.t
===================================================================
--- t/spec/S32-num/rat.t	(revision 28151)
+++ t/spec/S32-num/rat.t	(working copy)
@@ -18,12 +18,14 @@
 is(~(Rat.new(0,33)), "0/1", "Reduce to simplest form in constructor");
 
 # Test basic math
-is(~(1 div 4 + 1 div 4), "1/2", "1/4 + 1/4 = 1/2");
-is(~(1 div 4 + 2 div 7), "15/28", "1/4 + 2/7 = 15/28");
-is(~(1 div 4 + 1), "5/4", "1/4 + 1 = 5/4");
-is(~(1 + 1 div 4), "5/4", "1 + 1/4 = 5/4");
-is(~(1 div 4 - 1 div 4), "0/1", "1/4 - 1/4 = 0/1");
-is(~(1 div 4 - 3 div 4), "-1/2", "1/4 - 3/4 = -1/2");
+is(~(1 / 4 + 1 / 4), "1/2", "1/4 + 1/4 = 1/2");
+is(~(1 / 4 + 2 / 7), "15/28", "1/4 + 2/7 = 15/28");
+is(~(1 / 4 + 1), "5/4", "1/4 + 1 = 5/4");
+is(~(1 + 1 / 4), "5/4", "1 + 1/4 = 5/4");
+is(~(1 / 4 - 1 / 4), "0/1", "1/4 - 1/4 = 0/1");
+is(~(1 / 4 - 3 / 4), "-1/2", "1/4 - 3/4 = -1/2");
+is(~(1 / 4 - 1), "-3/4", "1/4 - 1 = -3/4");
+is(~(1 - 1 / 4), "3/4", "1 - 1/4 = 3/4");
 
 done_testing;
 
Index: t/spec/S02-literals/radix.t
===================================================================
--- t/spec/S02-literals/radix.t	(revision 28151)
+++ t/spec/S02-literals/radix.t	(working copy)
@@ -106,7 +106,7 @@
 # L<S02/Literals/"Any radix may include a fractional part">
 
 #?rakudo todo 'fractionals base 16'
-is(:16<dead_beef.face>,  0xDEAD_BEEF + 0xFACE / ( 16 ** 4 ), 'Fractional base 16 works' );
+is(:16<dead_beef.face>,  0xDEAD_BEEF + 0xFACE div ( 16 ** 4 ), 'Fractional base 16 works' );
 
 
 # L<S02/Literals/":8<177777>">
@@ -225,7 +225,7 @@
     is +":1_0<14_56>", 1456, "underscore seperators works";
     is +":10<123.456>", 123.456, "base 10 decimal notation works";
     is +":2<1.111>", 1.875, "base 2 decimal notation works";
-    is +":16<dead_beef.face>", 0xDEADBEEF + 0xFACE / (16 ** 4), "fractional base 16 works";
+    is +":16<dead_beef.face>", 0xDEADBEEF + 0xFACE div (16 ** 4), "fractional base 16 works";
 
     for 2..36 {
         is +":{$_}<11>", $_ + 1, "stringified form of base $_ works";
Index: t/spec/S02-magicals/dollar_bang.t
===================================================================
--- t/spec/S02-magicals/dollar_bang.t	(revision 28151)
+++ t/spec/S02-magicals/dollar_bang.t	(working copy)
@@ -34,7 +34,7 @@
 ok !$called, 'The subroutine also was not called';
 
 undefine $!;
-try { 1 / 0 };
+try { 1 div 0 };
 ok $!, 'Dividing one by zero sets $!';
 
 sub incr ( $a is rw ) { $a++ };