diff --git a/src/runtime/Native/ITypeOffsets.cs b/src/runtime/Native/ITypeOffsets.cs
index 0920a312a..7d71b4b91 100644
--- a/src/runtime/Native/ITypeOffsets.cs
+++ b/src/runtime/Native/ITypeOffsets.cs
@@ -31,6 +31,7 @@ interface ITypeOffsets
         int nb_invert { get; }
         int nb_inplace_add { get; }
         int nb_inplace_subtract { get; }
+        int nb_index { get; }
         int ob_size { get; }
         int ob_type { get; }
         int qualname { get; }
diff --git a/src/runtime/Native/TypeOffset.cs b/src/runtime/Native/TypeOffset.cs
index 847f1766d..803b86bfa 100644
--- a/src/runtime/Native/TypeOffset.cs
+++ b/src/runtime/Native/TypeOffset.cs
@@ -38,6 +38,7 @@ static partial class TypeOffset
         internal static int nb_invert { get; private set; }
         internal static int nb_inplace_add { get; private set; }
         internal static int nb_inplace_subtract { get; private set; }
+        internal static int nb_index { get; private set; }
         internal static int ob_size { get; private set; }
         internal static int ob_type { get; private set; }
         internal static int qualname { get; private set; }
diff --git a/src/runtime/Types/ClassBase.cs b/src/runtime/Types/ClassBase.cs
index 943841e25..7296a1900 100644
--- a/src/runtime/Types/ClassBase.cs
+++ b/src/runtime/Types/ClassBase.cs
@@ -604,6 +604,7 @@ public virtual void InitializeSlots(BorrowedReference pyType, SlotsHolder slotsH
                 case TypeCode.Int32:
                 case TypeCode.Int64:
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertInt), slotsHolder);
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_index, new Interop.B_N(DoConvertInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
                 case TypeCode.Byte:
@@ -611,10 +612,12 @@ public virtual void InitializeSlots(BorrowedReference pyType, SlotsHolder slotsH
                 case TypeCode.UInt32:
                 case TypeCode.UInt64:
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertUInt), slotsHolder);
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_index, new Interop.B_N(DoConvertUInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
                 case TypeCode.Double:
                 case TypeCode.Single:
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
             }
diff --git a/src/runtime/Types/OperatorMethod.cs b/src/runtime/Types/OperatorMethod.cs
index 88939a51d..e3cc23370 100644
--- a/src/runtime/Types/OperatorMethod.cs
+++ b/src/runtime/Types/OperatorMethod.cs
@@ -54,6 +54,7 @@ static OperatorMethod()
 
                 ["__int__"] = new SlotDefinition("__int__", TypeOffset.nb_int),
                 ["__float__"] = new SlotDefinition("__float__", TypeOffset.nb_float),
+                ["__index__"] = new SlotDefinition("__index__", TypeOffset.nb_index),
             };
             ComparisonOpMap = new Dictionary<string, string>
             {
diff --git a/src/runtime/Util/OpsHelper.cs b/src/runtime/Util/OpsHelper.cs
index 12d0c7aa6..7c35f27eb 100644
--- a/src/runtime/Util/OpsHelper.cs
+++ b/src/runtime/Util/OpsHelper.cs
@@ -82,10 +82,14 @@ internal static class EnumOps<T> where T : Enum
     {
         [ForbidPythonThreads]
 #pragma warning disable IDE1006 // Naming Styles - must match Python
-        public static PyInt __int__(T value)
+        public static PyInt __index__(T value)
 #pragma warning restore IDE1006 // Naming Styles
             => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)
             ? new PyInt(Convert.ToUInt64(value))
             : new PyInt(Convert.ToInt64(value));
+        [ForbidPythonThreads]
+#pragma warning disable IDE1006 // Naming Styles - must match Python
+        public static PyInt __int__(T value) => __index__(value);
+#pragma warning restore IDE1006 // Naming Styles
     }
 }
diff --git a/tests/test_conversion.py b/tests/test_conversion.py
index 69e7ec63f..bb686dd52 100644
--- a/tests/test_conversion.py
+++ b/tests/test_conversion.py
@@ -721,6 +721,7 @@ def test_intptr_construction():
             UIntPtr(v)
 
 def test_explicit_conversion():
+    from operator import index
     from System import (
         Int64, UInt64, Int32, UInt32, Int16, UInt16, Byte, SByte, Boolean
     )
@@ -730,18 +731,24 @@ def test_explicit_conversion():
     assert int(Boolean(True)) == 1
 
     for t in [UInt64, UInt32, UInt16, Byte]:
+        assert index(t(127)) == 127
         assert int(t(127)) == 127
         assert float(t(127)) == 127.0
 
     for t in [Int64, Int32, Int16, SByte]:
+        assert index(t(127)) == 127
+        assert index(t(-127)) == -127
         assert int(t(127)) == 127
         assert int(t(-127)) == -127
         assert float(t(127)) == 127.0
         assert float(t(-127)) == -127.0
 
-    assert int(Int64.MaxValue) == 2**63 - 1
-    assert int(Int64.MinValue) == -2**63
-    assert int(UInt64.MaxValue) == 2**64 - 1
+    assert int(Int64(Int64.MaxValue)) == 2**63 - 1
+    assert int(Int64(Int64.MinValue)) == -2**63
+    assert int(UInt64(UInt64.MaxValue)) == 2**64 - 1
 
     for t in [Single, Double]:
         assert float(t(0.125)) == 0.125
+        assert int(t(123.4)) == 123
+        with pytest.raises(TypeError):
+            index(t(123.4))