diff --git a/doc/changelog-old.dox b/doc/changelog-old.dox
index 7d5345826..62b757b7c 100644
--- a/doc/changelog-old.dox
+++ b/doc/changelog-old.dox
@@ -143,7 +143,7 @@ Released 2018-05-01, tagged as
 
 @subsubsection changelog-2018-04-changes-gl GL library
 
--   The @ref GL::Mesh::indexTypeSize() and @ref GL::MeshView::setIndexRange()
+-   The @ref GL::Mesh::indexTypeSize() and @cpp GL::MeshView::setIndexRange() @ce
     now expect that the mesh is indexed (instead of silently not doing
     anything)
 
@@ -1152,7 +1152,7 @@ a high-level overview.
     instead
 -   Removed deprecated `Mesh*::set*{Range,Count}()` functions, use
     @ref GL::Mesh::setCount() "Mesh*::setCount()" and
-    @ref GL::MeshView::setIndexRange() "MeshView::setIndexRange()" instead
+    @cpp MeshView::setIndexRange() @ce instead
 -   Removed deprecated parameterless @cpp GL::Mesh::draw() @ce overload, use
     the one with explicit shader parameter instead
 -   Removed deprecated `Context::Flag::Robustness` enum value, use
diff --git a/doc/changelog.dox b/doc/changelog.dox
index e0abb7695..fe5cc6bc4 100644
--- a/doc/changelog.dox
+++ b/doc/changelog.dox
@@ -1073,6 +1073,8 @@ See also:
     callback function pointer is deprecated in favor of a version taking a
     @ref Containers::StringView. See also [mosra/magnum#499](https://github.com/mosra/magnum/pull/499)
     and [mosra/magnum#596](https://github.com/mosra/magnum/pull/596).
+-   @cpp GL::MeshView::setIndexRange() @ce is deprecated in favor of
+    @ref GL::MeshView::setIndexOffset() that has a much less confusing name
 -   The @cpp Array @ce, @cpp Array1D @ce, @cpp Array2D @ce and
     @cpp Array3D @ce types that were used exclusively for specifying
     @ref SamplerWrapping in various texture APIs are deprecated in favor of
diff --git a/src/Magnum/GL/AbstractShaderProgram.h b/src/Magnum/GL/AbstractShaderProgram.h
index e4226d188..f51a70c51 100644
--- a/src/Magnum/GL/AbstractShaderProgram.h
+++ b/src/Magnum/GL/AbstractShaderProgram.h
@@ -1301,7 +1301,7 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
          *
          * Everything set by @ref MeshView::setCount(),
          * @ref MeshView::setBaseInstance(), @ref MeshView::setBaseVertex(),
-         * @ref MeshView::setIndexRange() and @ref Mesh::setIndexBuffer() is
+         * @ref MeshView::setIndexOffset() and @ref Mesh::setIndexBuffer() is
          * ignored, the mesh is drawn as non-indexed and the vertex count is
          * taken from the @p xfb object. See
          * @ref drawTransformFeedback(Mesh&, TransformFeedback&, UnsignedInt)
diff --git a/src/Magnum/GL/Mesh.h b/src/Magnum/GL/Mesh.h
index 95f8ee09e..017765311 100644
--- a/src/Magnum/GL/Mesh.h
+++ b/src/Magnum/GL/Mesh.h
@@ -1037,7 +1037,8 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
          *
          * Alternative to @ref setIndexBuffer(Buffer&, GLintptr, MeshIndexType, UnsignedInt, UnsignedInt)
          * with unspecified index limits, see its documentation for more
-         * information. Prefer to set index limits for better performance.
+         * information. Prefer to set index limits for better performance on
+         * certain drivers.
          */
         Mesh& setIndexBuffer(Buffer& buffer, GLintptr offset, MeshIndexType type) {
             return setIndexBuffer(buffer, offset, type, 0, 0);
diff --git a/src/Magnum/GL/MeshView.cpp b/src/Magnum/GL/MeshView.cpp
index 874969ef2..4483a4800 100644
--- a/src/Magnum/GL/MeshView.cpp
+++ b/src/Magnum/GL/MeshView.cpp
@@ -56,9 +56,10 @@ void MeshView::draw(AbstractShaderProgram&& shader, std::initializer_list<Contai
 }
 #endif
 
-MeshView& MeshView::setIndexRange(Int first) {
-     CORRADE_ASSERT(_original.get()._indexBuffer.id(), "MeshView::setIndexRange(): mesh is not indexed", *this);
-    _indexOffset = _original.get()._indexOffset + first*_original.get().indexTypeSize();
+MeshView& MeshView::setIndexOffset(Int offset) {
+    CORRADE_ASSERT(_original.get()._indexBuffer.id(),
+        "GL::MeshView::setIndexOffset(): mesh is not indexed", *this);
+    _indexOffset = _original.get()._indexOffset + offset*_original.get().indexTypeSize();
     return *this;
 }
 
diff --git a/src/Magnum/GL/MeshView.h b/src/Magnum/GL/MeshView.h
index 8e6679f41..716ba9563 100644
--- a/src/Magnum/GL/MeshView.h
+++ b/src/Magnum/GL/MeshView.h
@@ -147,16 +147,17 @@ class MAGNUM_GL_EXPORT MeshView {
         }
 
         /**
-         * @brief Set index range
-         * @param first     First vertex
+         * @brief Set index offset
+         * @param offset    First index
          * @param start     Minimum array index contained in the buffer
          * @param end       Maximum array index contained in the buffer
          * @return Reference to self (for method chaining)
+         * @m_since_latest
          *
          * The @p start and @p end parameters may help to improve memory access
          * performance, as only a portion of vertex buffer needs to be
          * acccessed. On OpenGL ES 2.0 this function behaves the same as
-         * @ref setIndexRange(Int), as index range functionality is not
+         * @ref setIndexOffset(Int), as index range functionality is not
          * available there. Ignored when calling
          * @ref AbstractShaderProgram::drawTransformFeedback().
          *
@@ -164,21 +165,41 @@ class MAGNUM_GL_EXPORT MeshView {
          * @see @ref setCount(), @ref mesh(), @ref Mesh::isIndexed()
          */
         /* MinGW/MSVC needs inline also here to avoid linkage conflicts */
-        inline MeshView& setIndexRange(Int first, UnsignedInt start, UnsignedInt end);
+        inline MeshView& setIndexOffset(Int offset, UnsignedInt start, UnsignedInt end);
 
+        #ifdef MAGNUM_BUILD_DEPRECATED
         /**
-         * @brief Set index range
-         * @param first     First index
+         * @brief @copybrief setIndexOffset(Int, UnsignedInt, UnsignedInt)
+         * @m_deprecated_since_latest Use @ref setIndexOffset(Int, UnsignedInt, UnsignedInt) instead.
+         */
+        CORRADE_DEPRECATED("use setIndexOffset() instead") MeshView& setIndexRange(Int offset, UnsignedInt start, UnsignedInt end) {
+            return setIndexOffset(offset, start, end);
+        }
+        #endif
+
+        /**
+         * @brief Set index offset
          * @return Reference to self (for method chaining)
+         * @m_since_latest
          *
-         * Prefer to use @ref setIndexRange(Int, UnsignedInt, UnsignedInt) for
-         * better performance. Ignored when calling
-         * @ref AbstractShaderProgram::drawTransformFeedback().
+         * Prefer to use @ref setIndexOffset(Int, UnsignedInt, UnsignedInt) for
+         * potential better performance in certain drivers. Ignored when
+         * calling @ref AbstractShaderProgram::drawTransformFeedback().
          *
          * Expects that the original mesh is indexed.
          * @see @ref setCount(), @ref mesh(), @ref Mesh::isIndexed()
          */
-        MeshView& setIndexRange(Int first);
+        MeshView& setIndexOffset(Int offset);
+
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief @copybrief setIndexOffset(Int)
+         * @m_deprecated_since_latest Use @ref setIndexOffset(Int) instead.
+         */
+        CORRADE_DEPRECATED("use setIndexOffset() instead") MeshView& setIndexRange(Int offset) {
+            return setIndexOffset(offset);
+        }
+        #endif
 
         /** @brief Instance count */
         Int instanceCount() const { return _instanceCount; }
@@ -283,8 +304,8 @@ class MAGNUM_GL_EXPORT MeshView {
 
 inline MeshView::MeshView(Mesh& original): _original{original} {}
 
-inline MeshView& MeshView::setIndexRange(Int first, UnsignedInt start, UnsignedInt end) {
-    setIndexRange(first);
+inline MeshView& MeshView::setIndexOffset(Int first, UnsignedInt start, UnsignedInt end) {
+    setIndexOffset(first);
     #ifndef MAGNUM_TARGET_GLES2
     _indexStart = start;
     _indexEnd = end;
diff --git a/src/Magnum/GL/Test/MeshGLTest.cpp b/src/Magnum/GL/Test/MeshGLTest.cpp
index 0554cae2b..efb30968d 100644
--- a/src/Magnum/GL/Test/MeshGLTest.cpp
+++ b/src/Magnum/GL/Test/MeshGLTest.cpp
@@ -141,6 +141,8 @@ struct MeshGLTest: OpenGLTester {
     template<class T> void setIndexBufferTransferOwnership();
     template<class T> void setIndexBufferRangeTransferOwnership();
 
+    void setIndexOffsetNotIndexed();
+
     void unbindVAOWhenSettingIndexBufferData();
     void unbindIndexBufferWhenBindingVao();
     void resetIndexBufferBindingWhenBindingVao();
@@ -631,6 +633,8 @@ MeshGLTest::MeshGLTest() {
               &MeshGLTest::setIndexBufferRangeTransferOwnership<GL::MeshIndexType>,
               &MeshGLTest::setIndexBufferRangeTransferOwnership<Magnum::MeshIndexType>,
 
+              &MeshGLTest::setIndexOffsetNotIndexed,
+
               &MeshGLTest::unbindVAOWhenSettingIndexBufferData,
               &MeshGLTest::unbindIndexBufferWhenBindingVao,
               &MeshGLTest::resetIndexBufferBindingWhenBindingVao,
@@ -1133,7 +1137,7 @@ Checker::Checker(AbstractShaderProgram&& shader, RenderbufferFormat format, Mesh
         #endif
         ;
 
-    if(view.mesh().isIndexed()) view.setIndexRange(1);
+    if(view.mesh().isIndexed()) view.setIndexOffset(1);
 
     shader.draw(view);
 }
@@ -2676,6 +2680,18 @@ template<class T> void MeshGLTest::setIndexBufferRangeTransferOwnership() {
     CORRADE_VERIFY(!glIsBuffer(id));
 }
 
+void MeshGLTest::setIndexOffsetNotIndexed() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    Mesh mesh;
+    MeshView view{mesh};
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    view.setIndexOffset(3);
+    CORRADE_COMPARE(out.str(), "GL::MeshView::setIndexOffset(): mesh is not indexed\n");
+}
+
 void MeshGLTest::unbindVAOWhenSettingIndexBufferData() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
@@ -4368,16 +4384,16 @@ void MeshGLTest::multiDrawIndexedViews() {
 
     MeshView a{mesh}, b{mesh}, c{mesh}, d{mesh};
     a.setCount(data.counts[0])
-     .setIndexRange(data.indexOffsetsInBytes[0]/sizeof(UnsignedInt))
+     .setIndexOffset(data.indexOffsetsInBytes[0]/sizeof(UnsignedInt))
      .setBaseVertex(data.vertexOffsets[0]);
     b.setCount(data.counts[1])
-     .setIndexRange(data.indexOffsetsInBytes[1]/sizeof(UnsignedInt))
+     .setIndexOffset(data.indexOffsetsInBytes[1]/sizeof(UnsignedInt))
      .setBaseVertex(data.vertexOffsets[1]);
     c.setCount(data.counts[2])
-     .setIndexRange(data.indexOffsetsInBytes[2]/sizeof(UnsignedInt))
+     .setIndexOffset(data.indexOffsetsInBytes[2]/sizeof(UnsignedInt))
      .setBaseVertex(data.vertexOffsets[2]);
     d.setCount(data.counts[3])
-     .setIndexRange(data.indexOffsetsInBytes[3]/sizeof(UnsignedInt))
+     .setIndexOffset(data.indexOffsetsInBytes[3]/sizeof(UnsignedInt))
      .setBaseVertex(data.vertexOffsets[3]);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
diff --git a/src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp b/src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
index 1a821d7ba..ec1d28712 100644
--- a/src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
+++ b/src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
@@ -1344,10 +1344,10 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
     circle.setCount(circleData.indexCount());
     GL::MeshView square{mesh};
     square.setCount(squareData.indexCount())
-        .setIndexRange(circleData.indexCount());
+        .setIndexOffset(circleData.indexCount());
     GL::MeshView triangle{mesh};
     triangle.setCount(triangleData.indexCount())
-        .setIndexRange(circleData.indexCount() + squareData.indexCount());
+        .setIndexOffset(circleData.indexCount() + squareData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -1564,10 +1564,10 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
     sphere.setCount(sphereData.indexCount());
     GL::MeshView plane{mesh};
     plane.setCount(planeData.indexCount())
-        .setIndexRange(sphereData.indexCount());
+        .setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(coneData.indexCount())
-        .setIndexRange(sphereData.indexCount() + planeData.indexCount());
+        .setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
diff --git a/src/Magnum/Shaders/Test/FlatGLTest.cpp b/src/Magnum/Shaders/Test/FlatGLTest.cpp
index f5bb72b0f..6007f897e 100644
--- a/src/Magnum/Shaders/Test/FlatGLTest.cpp
+++ b/src/Magnum/Shaders/Test/FlatGLTest.cpp
@@ -5069,10 +5069,10 @@ void FlatGLTest::renderMulti2D() {
     circle.setCount(circleData.indexCount());
     GL::MeshView square{mesh};
     square.setCount(squareData.indexCount())
-        .setIndexRange(circleData.indexCount());
+        .setIndexOffset(circleData.indexCount());
     GL::MeshView triangle{mesh};
     triangle.setCount(triangleData.indexCount())
-        .setIndexRange(circleData.indexCount() + squareData.indexCount());
+        .setIndexOffset(circleData.indexCount() + squareData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -5434,10 +5434,10 @@ void FlatGLTest::renderMulti3D() {
     sphere.setCount(sphereData.indexCount());
     GL::MeshView plane{mesh};
     plane.setCount(planeData.indexCount())
-        .setIndexRange(sphereData.indexCount());
+        .setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(coneData.indexCount())
-        .setIndexRange(sphereData.indexCount() + planeData.indexCount());
+        .setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -5742,10 +5742,10 @@ void FlatGLTest::renderMultiSkinning2D() {
     square.setCount(6);
     GL::MeshView triangle1{mesh};
     triangle1.setCount(3)
-        .setIndexRange(6);
+        .setIndexOffset(6);
     GL::MeshView triangle2{mesh};
     triangle2.setCount(3)
-        .setIndexRange(9);
+        .setIndexOffset(9);
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -5994,10 +5994,10 @@ void FlatGLTest::renderMultiSkinning3D() {
     square.setCount(6);
     GL::MeshView triangle1{mesh};
     triangle1.setCount(3)
-        .setIndexRange(6);
+        .setIndexOffset(6);
     GL::MeshView triangle2{mesh};
     triangle2.setCount(3)
-        .setIndexRange(9);
+        .setIndexOffset(9);
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
diff --git a/src/Magnum/Shaders/Test/LineGLTest.cpp b/src/Magnum/Shaders/Test/LineGLTest.cpp
index 64d2abc0a..0eac34084 100644
--- a/src/Magnum/Shaders/Test/LineGLTest.cpp
+++ b/src/Magnum/Shaders/Test/LineGLTest.cpp
@@ -2709,10 +2709,10 @@ void LineGLTest::renderMulti2D() {
     wave.setCount(30);
     GL::MeshView cross{lines};
     cross.setCount(12)
-        .setIndexRange(30);
+        .setIndexOffset(30);
     GL::MeshView point{lines};
     point.setCount(6)
-        .setIndexRange(42);
+        .setIndexOffset(42);
 
     LineGL2D shader{LineGL2D::Configuration{}
         .setFlags(LineGL2D::Flag::UniformBuffers|data.flags)
@@ -2940,10 +2940,10 @@ void LineGLTest::renderMulti3D() {
     wave.setCount(30);
     GL::MeshView cross{lines};
     cross.setCount(12)
-        .setIndexRange(30);
+        .setIndexOffset(30);
     GL::MeshView point{lines};
     point.setCount(6)
-        .setIndexRange(42);
+        .setIndexOffset(42);
 
     LineGL3D shader{LineGL3D::Configuration{}
         .setFlags(LineGL3D::Flag::UniformBuffers|data.flags)
diff --git a/src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp b/src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
index 735a67173..16904b7d1 100644
--- a/src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
+++ b/src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
@@ -6693,13 +6693,13 @@ void MeshVisualizerGLTest::renderMulti2D() {
     if(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader)
         square.setBaseVertex(circleData.vertexCount());
     else
-        square.setIndexRange(circleData.indexCount());
+        square.setIndexOffset(circleData.indexCount());
     GL::MeshView triangle{mesh};
     triangle.setCount(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader ?
         triangleData.vertexCount() : triangleData.indexCount());
     if(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader)
         triangle.setBaseVertex(circleData.vertexCount() + squareData.vertexCount());
-    else triangle.setIndexRange(circleData.indexCount() + squareData.indexCount());
+    else triangle.setIndexOffset(circleData.indexCount() + squareData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -7035,13 +7035,13 @@ void MeshVisualizerGLTest::renderMulti3D() {
     if(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader)
         plane.setBaseVertex(sphereData.vertexCount());
     else
-        plane.setIndexRange(sphereData.indexCount());
+        plane.setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader ?
         coneData.vertexCount() : coneData.indexCount());
     if(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader)
         cone.setBaseVertex(sphereData.vertexCount() + planeData.vertexCount());
-    else cone.setIndexRange(sphereData.indexCount() + planeData.indexCount());
+    else cone.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
         ProjectionUniform3D{}.setProjectionMatrix(
diff --git a/src/Magnum/Shaders/Test/PhongGLTest.cpp b/src/Magnum/Shaders/Test/PhongGLTest.cpp
index 5c5e04a49..a674d6b21 100644
--- a/src/Magnum/Shaders/Test/PhongGLTest.cpp
+++ b/src/Magnum/Shaders/Test/PhongGLTest.cpp
@@ -5481,10 +5481,10 @@ void PhongGLTest::renderMulti() {
     sphere.setCount(sphereData.indexCount());
     GL::MeshView plane{mesh};
     plane.setCount(planeData.indexCount())
-        .setIndexRange(sphereData.indexCount());
+        .setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(coneData.indexCount())
-        .setIndexRange(sphereData.indexCount() + planeData.indexCount());
+        .setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
         ProjectionUniform3D{}.setProjectionMatrix(
@@ -5830,10 +5830,10 @@ void PhongGLTest::renderMultiSkinning() {
     square.setCount(6);
     GL::MeshView triangle1{mesh};
     triangle1.setCount(3)
-        .setIndexRange(6);
+        .setIndexOffset(6);
     GL::MeshView triangle2{mesh};
     triangle2.setCount(3)
-        .setIndexRange(9);
+        .setIndexOffset(9);
 
     GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
         ProjectionUniform3D{}
diff --git a/src/Magnum/Shaders/Test/VectorGLTest.cpp b/src/Magnum/Shaders/Test/VectorGLTest.cpp
index 60d292617..754558152 100644
--- a/src/Magnum/Shaders/Test/VectorGLTest.cpp
+++ b/src/Magnum/Shaders/Test/VectorGLTest.cpp
@@ -1309,10 +1309,10 @@ void VectorGLTest::renderMulti2D() {
     circle.setCount(circleData.indexCount());
     GL::MeshView square{mesh};
     square.setCount(squareData.indexCount())
-        .setIndexRange(circleData.indexCount());
+        .setIndexOffset(circleData.indexCount());
     GL::MeshView triangle{mesh};
     triangle.setCount(triangleData.indexCount())
-        .setIndexRange(circleData.indexCount() + squareData.indexCount());
+        .setIndexOffset(circleData.indexCount() + squareData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -1529,10 +1529,10 @@ void VectorGLTest::renderMulti3D() {
     sphere.setCount(sphereData.indexCount());
     GL::MeshView plane{mesh};
     plane.setCount(planeData.indexCount())
-        .setIndexRange(sphereData.indexCount());
+        .setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(coneData.indexCount())
-        .setIndexRange(sphereData.indexCount() + planeData.indexCount());
+        .setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
diff --git a/src/Magnum/Shaders/Test/VertexColorGLTest.cpp b/src/Magnum/Shaders/Test/VertexColorGLTest.cpp
index 4f07d039d..f34c94696 100644
--- a/src/Magnum/Shaders/Test/VertexColorGLTest.cpp
+++ b/src/Magnum/Shaders/Test/VertexColorGLTest.cpp
@@ -1058,10 +1058,10 @@ void VertexColorGLTest::renderMulti2D() {
     circle.setCount(circleData.indexCount());
     GL::MeshView square{mesh};
     square.setCount(squareData.indexCount())
-        .setIndexRange(circleData.indexCount());
+        .setIndexOffset(circleData.indexCount());
     GL::MeshView triangle{mesh};
     triangle.setCount(triangleData.indexCount())
-        .setIndexRange(circleData.indexCount() + squareData.indexCount());
+        .setIndexOffset(circleData.indexCount() + squareData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.
@@ -1204,10 +1204,10 @@ void VertexColorGLTest::renderMulti3D() {
     sphere.setCount(sphereData.indexCount());
     GL::MeshView plane{mesh};
     plane.setCount(planeData.indexCount())
-        .setIndexRange(sphereData.indexCount());
+        .setIndexOffset(sphereData.indexCount());
     GL::MeshView cone{mesh};
     cone.setCount(coneData.indexCount())
-        .setIndexRange(sphereData.indexCount() + planeData.indexCount());
+        .setIndexOffset(sphereData.indexCount() + planeData.indexCount());
 
     /* Some drivers have uniform offset alignment as high as 256, which means
        the subsequent sets of uniforms have to be aligned to a multiply of it.